Skipping /home/juanjose/projects/parrot-bleed/src/exec_save.c due to parse error
=====================================================================
Found a 126 line (421 tokens) duplication in the following files: 
Starting at line 954 of /home/juanjose/projects/parrot-bleed/src/jit/sun4/jit_emit.h
Starting at line 2618 of /home/juanjose/projects/parrot-bleed/src/jit/i386/jit_emit.h
            break;
    }
}

/* emit a call to a vtable func
 * $1->vtable(interp, $1)
 */
static void
Parrot_jit_vtable1_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    int a[] = { 1 };
    Parrot_jit_vtable_n_op(jit_info, interpreter, 1, a);
}

/* emit a call to a vtable func
 * $1 = $2->vtable(interp, $2)
 */
static void
Parrot_jit_vtable1r_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    int a[] = { 2 };
    Parrot_jit_vtable_n_op(jit_info, interpreter, 1, a);
    Parrot_jit_store_retval(jit_info, interpreter);
}


/* emit a call to a vtable func
 * $1 = $2->vtable(interp, $2, $3)
 */
static void
Parrot_jit_vtable_1r223_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    int a[] = { 2 , 3};
    Parrot_jit_vtable_n_op(jit_info, interpreter, 2, a);
    Parrot_jit_store_retval(jit_info, interpreter);
}

/* emit a call to a vtable func
 * $1 = $3->vtable(interp, $3, $2)
 */
static void
Parrot_jit_vtable_1r332_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    int a[] = { 3 , 2};
    Parrot_jit_vtable_n_op(jit_info, interpreter, 2, a);
    Parrot_jit_store_retval(jit_info, interpreter);
}
/* emit a call to a vtable func
 * $1->vtable(interp, $1, $2)
 */
static void
Parrot_jit_vtable_112_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    int a[] = { 1, 2 };
    Parrot_jit_vtable_n_op(jit_info, interpreter, 2, a);
}

/* emit a call to a vtable func
 * $1->vtable(interp, $1, $1)
 */
static void
Parrot_jit_vtable_111_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    int a[] = { 1, 1 };
    Parrot_jit_vtable_n_op(jit_info, interpreter, 2, a);
}
/* emit a call to a vtable func
 * $2->vtable(interp, $2, $1)
 */
static void
Parrot_jit_vtable_221_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    int a[] = { 2, 1 };
    Parrot_jit_vtable_n_op(jit_info, interpreter, 2, a);
}

/* emit a call to a vtable func
 * $2->vtable(interp, $2, $3, $1)
 */
static void
Parrot_jit_vtable_2231_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    int a[] = { 2, 3, 1 };
    Parrot_jit_vtable_n_op(jit_info, interpreter, 3, a);
}

/* emit a call to a vtable func
 * $1->vtable(interp, $1, $2, $3)
 */
static void
Parrot_jit_vtable_1123_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    int a[] = { 1, 2, 3 };
    Parrot_jit_vtable_n_op(jit_info, interpreter, 3, a);
}

/* emit a call to a vtable func
 * $1->vtable(interp, $1, $2, $1)
 */
static void
Parrot_jit_vtable_1121_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    int a[] = { 1, 2, 1 };
    Parrot_jit_vtable_n_op(jit_info, interpreter, 3, a);
}


/* if_p_ic, unless_p_ic */
static void
Parrot_jit_vtable_if_unless_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter, int unless)
{
    int ic = *(jit_info->cur_op + 2);   /* branch offset */

    /* emit call  vtable function i.e. get_bool, result eax */
    Parrot_jit_vtable1_op(jit_info, interpreter);
=====================================================================
Found a 50 line (268 tokens) duplication in the following files: 
Starting at line 1409 of /home/juanjose/projects/parrot-bleed/src/string.c
Starting at line 1478 of /home/juanjose/projects/parrot-bleed/src/string.c
string_bitwise_xor(Interp *interpreter, STRING *s1, STRING *s2, STRING **dest)
{
    STRING *res;
    size_t maxlen = 0;

    if (s1) {
        if (s1->encoding != Parrot_fixed_8_encoding_ptr) {
            real_exception(interpreter, NULL, INVALID_ENCODING,
                    "string bitwise_and (%s/%s) unsupported",
                    ((ENCODING *)(s1->encoding))->name,
                    ((ENCODING *)(s2->encoding))->name);
        }
        maxlen = s1->bufused;
    }
    if (s2) {
        if (s2->encoding != Parrot_fixed_8_encoding_ptr) {
            real_exception(interpreter, NULL, INVALID_ENCODING,
                    "string bitwise_and (%s/%s) unsupported",
                    ((ENCODING *)(s2->encoding))->name,
                    ((ENCODING *)(s2->encoding))->name);
        }
        if (s2->bufused > maxlen)
            maxlen = s2->bufused;
    }

    if (dest && *dest) {
        res = *dest;
        res->encoding = Parrot_fixed_8_encoding_ptr;
        res->charset  = Parrot_binary_charset_ptr;
    }
    else
        res = string_make_direct(interpreter, NULL, maxlen,
                Parrot_fixed_8_encoding_ptr, Parrot_binary_charset_ptr, 0);

    if (!maxlen) {
        res->bufused = 0;
        res->strlen = 0;
        return res;
    }

#if ! DISABLE_GC_DEBUG
    /* trigger GC for debug */
    if (interpreter && GC_DEBUG(interpreter))
        Parrot_do_dod_run(interpreter, DOD_trace_stack_FLAG);
#endif

    make_writable(interpreter, &res, maxlen, enum_stringrep_one);

    BITWISE_OR_STRINGS(Parrot_UInt1, Parrot_UInt1, Parrot_UInt1,
            s1, s2, res, maxlen, ^);
=====================================================================
Found a 17 line (261 tokens) duplication in the following files: 
Starting at line 17 of /home/juanjose/projects/parrot-bleed/src/charset/tables.c
Starting at line 51 of /home/juanjose/projects/parrot-bleed/src/charset/tables.c
const PARROT_CCLASS_FLAGS Parrot_iso_8859_1_typetable[256] = {
0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, /* 0-7 */
0x0200, 0x0320, 0x1220, 0x0220, 0x1220, 0x1220, 0x0200, 0x0200, /* 8-15 */
0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, /* 16-23 */
0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, /* 24-31 */
0x0160, 0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x04c0, /* 32-39 */
0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x04c0, /* 40-47 */
0x28d8, 0x28d8, 0x28d8, 0x28d8, 0x28d8, 0x28d8, 0x28d8, 0x28d8, /* 48-55 */
0x28d8, 0x28d8, 0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x04c0, /* 56-63 */
0x04c0, 0x28d5, 0x28d5, 0x28d5, 0x28d5, 0x28d5, 0x28d5, 0x28c5, /* 64-71 */
0x28c5, 0x28c5, 0x28c5, 0x28c5, 0x28c5, 0x28c5, 0x28c5, 0x28c5, /* 72-79 */
0x28c5, 0x28c5, 0x28c5, 0x28c5, 0x28c5, 0x28c5, 0x28c5, 0x28c5, /* 80-87 */
0x28c5, 0x28c5, 0x28c5, 0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x24c0, /* 88-95 */
0x04c0, 0x28d6, 0x28d6, 0x28d6, 0x28d6, 0x28d6, 0x28d6, 0x28c6, /* 96-103 */
0x28c6, 0x28c6, 0x28c6, 0x28c6, 0x28c6, 0x28c6, 0x28c6, 0x28c6, /* 104-111 */
0x28c6, 0x28c6, 0x28c6, 0x28c6, 0x28c6, 0x28c6, 0x28c6, 0x28c6, /* 112-119 */
0x28c6, 0x28c6, 0x28c6, 0x04c0, 0x04c0, 0x04c0, 0x04c0, 0x0200, /* 120-127 */
=====================================================================
Found a 41 line (256 tokens) duplication in the following files: 
Starting at line 256 of /home/juanjose/projects/parrot-bleed/src/jit_debug_xcoff.c
Starting at line 288 of /home/juanjose/projects/parrot-bleed/src/jit_debug.c
    struct PackFile_Debug *debug;

    if (interpreter->code->debugs) {
        char *ext;
        char *src = string_to_cstring(interpreter,
            Parrot_debug_pc_to_filename(interpreter,
            interpreter->code->debugs, 0));
        pasmfile = string_make(interpreter, src, strlen(src), NULL,
                PObj_external_FLAG);
        file = string_copy(interpreter, pasmfile);
        /* chop pasm/pir */

        ext = strrchr(src, '.');
        if (ext && strcmp (ext, ".pasm") == 0)
            file = string_chopn(interpreter, file, 4, 1);
        else if (ext && strcmp (ext, ".pir") == 0)
            file = string_chopn(interpreter, file, 3, 1);
        else if (!ext) /* EVAL_n */
            file = string_append(interpreter, file,
                    string_make(interpreter, ".", 1, NULL, PObj_external_FLAG),
                    0);
    }
    else {
        /* chop pbc */
        file = string_chopn(interpreter, file, 3, 1);
        pasmfile = debug_file(interpreter, file, "pasm");
    }
    stabsfile = debug_file(interpreter, file, "stabs.s");
    ofile = debug_file(interpreter, file, "o");
    {
    	char *temp = string_to_cstring(interpreter,stabsfile);
        stabs = fopen(temp, "w");
        free(temp);
    }
    if (stabs == NULL)
        return;

    {
    	char *temp = string_to_cstring(interpreter, pasmfile);
        /* filename info */
        fprintf(stabs, ".data\n.text\n");       /* darwin wants it */
=====================================================================
Found a 48 line (230 tokens) duplication in the following files: 
Starting at line 163 of /home/juanjose/projects/parrot-bleed/src/encodings/utf16.c
Starting at line 404 of /home/juanjose/projects/parrot-bleed/src/encodings/utf8.c
    utf8_encode(p, codepoint);
}

static UINTVAL
get_byte(Interp *interpreter, const STRING *src, UINTVAL offset)
{
    unsigned char *contents = src->strstart;
    if (offset >= src->bufused) {
/*	internal_exception(0,
		"get_byte past the end of the buffer (%i of %i)",
		offset, src->bufused);*/
	return 0;
    }
    return contents[offset];
}

static void
set_byte(Interp *interpreter, const STRING *src,
	UINTVAL offset, UINTVAL byte)
{
    unsigned char *contents;
    if (offset >= src->bufused) {
	internal_exception(0, "set_byte past the end of the buffer");
    }
    contents = src->strstart;
    contents[offset] = (unsigned char)byte;
}

static STRING *
get_codepoints(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count)
{
    String_iter iter;
    UINTVAL start;
    STRING *return_string = Parrot_make_COW_reference(interpreter,
	    src);
    iter_init(interpreter, src, &iter);
    iter.set_position(interpreter, &iter, offset);
    start = iter.bytepos;
    return_string->strstart = (char *)return_string->strstart + start ;
    iter.set_position(interpreter, &iter, offset + count);
    return_string->bufused = iter.bytepos - start;
    return_string->strlen = count;
    return_string->hashval = 0;
    return return_string;
}

static STRING *
=====================================================================
Found a 6 line (192 tokens) duplication in the following files: 
Starting at line 28 of /home/juanjose/projects/parrot-bleed/src/encodings/utf8.c
Starting at line 34 of /home/juanjose/projects/parrot-bleed/src/encodings/utf8.c
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,     /* ascii */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,     /* ascii */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,     /* bogus */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,     /* bogus */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,     /* bogus */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,     /* bogus */
=====================================================================
Found a 23 line (182 tokens) duplication in the following files: 
Starting at line 291 of /home/juanjose/projects/parrot-bleed/src/byteorder.c
Starting at line 316 of /home/juanjose/projects/parrot-bleed/src/byteorder.c
fetch_buf_be_16(unsigned char *rb, unsigned char *b)
{
#if PARROT_BIGENDIAN
    memcpy(rb, b, 16);
#else
    rb[0] = b[15];
    rb[1] = b[14];
    rb[2] = b[13];
    rb[3] = b[12];
    rb[4] = b[11];
    rb[5] = b[10];
    rb[6] = b[9];
    rb[7] = b[8];
    rb[8] = b[7];
    rb[9] = b[6];
    rb[10] = b[5];
    rb[11] = b[4];
    rb[12] = b[3];
    rb[13] = b[2];
    rb[14] = b[1];
    rb[15] = b[0];
#endif
}
=====================================================================
Found a 55 line (172 tokens) duplication in the following files: 
Starting at line 234 of /home/juanjose/projects/parrot-bleed/src/encodings/utf16.c
Starting at line 485 of /home/juanjose/projects/parrot-bleed/src/encodings/utf8.c
    return return_string;
}

static STRING *
get_bytes_inplace(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count, STRING *return_string)
{
    UNIMPL;
    return NULL;
}

static void
set_codepoints(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count, STRING *new_codepoints)
{
    UNIMPL;
}

static void
set_bytes(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count, STRING *new_bytes)
{
    UNIMPL;
}

/* Unconditionally makes the string be in this encoding, if that's
   valid */
static void
become_encoding(Interp *interpreter, STRING *src)
{
    UNIMPL;
}


static UINTVAL
codepoints(Interp *interpreter, STRING *src)
{
    String_iter iter;
    /*
     * this is used to initially calculate src->strlen,
     * therefore we must scan the whole string
     */
    iter_init(interpreter, src, &iter);
    while (iter.bytepos < src->bufused)
        iter.get_and_advance(interpreter, &iter);
    return iter.charpos;
}

static UINTVAL
bytes(Interp *interpreter, STRING *src)
{
    return src->bufused;
}

static void
=====================================================================
Found a 25 line (171 tokens) duplication in the following files: 
Starting at line 1116 of /home/juanjose/projects/parrot-bleed/src/jit.c
Starting at line 1187 of /home/juanjose/projects/parrot-bleed/src/jit.c
Parrot_jit_save_registers(Parrot_jit_info_t *jit_info,
                          Interp * interpreter, int volatiles)
{
    Parrot_jit_optimizer_section_t *sect = jit_info->optimizer->cur_section;
    Parrot_jit_register_usage_t *ru = sect->ru;
    int i, typ;
    size_t offs;
    int base_reg = 0; /* -O3 warning */
    int lasts[] = { 0, 0, 0, 0 };
    const char * maps[] = {0, 0, 0, 0};
    int first = 1;
    int code_type;
    const jit_arch_info *arch_info;
    const jit_arch_regs *reg_info;

    arch_info = jit_info->arch_info;   
    code_type = jit_info->code_type;
    reg_info = arch_info->regs + code_type;
    maps[0]  = reg_info->map_I;
    maps[3]  = reg_info->map_F;
    lasts[0] = reg_info->n_preserved_I;
    lasts[3] = reg_info->n_preserved_F;

    for (typ = 0; typ < 4; typ++) {
        if (maps[typ])
=====================================================================
Found a 30 line (168 tokens) duplication in the following files: 
Starting at line 968 of /home/juanjose/projects/parrot-bleed/src/jit/ppc/jit_emit.h
Starting at line 3084 of /home/juanjose/projects/parrot-bleed/src/jit/i386/jit_emit.h
    reg_info = &jit_info->arch_info->regs[jit_info->code_type]; 

    if (!recursive) {
        /* create args array */
        internal_exception(1, "set_args_jit - can't do that yet ");
    }

    constants = CONTEXT(interpreter->ctx)->constants;
    sig_args = constants[CUR_OPCODE[1]]->u.key;
    if (!SIG_ELEMS(sig_args))
        return;
    params = jit_info->optimizer->sections->begin;
    sig_params = constants[params[1]]->u.key;
    ASSERT_SIG_PMC(sig_params);
    sig_bits = SIG_ARRAY(sig_args);
    n = SIG_ELEMS(sig_args);  
    /*
     * preserve registers - need get_results, because we skip the 
     * return value
     */
    result = CUR_OPCODE + 2 + n + 3; /* set_args, set_p_pc */
    assert(*result == PARROT_OP_get_results_pc);
    sig_result = constants[result[1]]->u.key;
    ASSERT_SIG_PMC(sig_result);

    if (!SIG_ELEMS(sig_result))
        skip = -1;
    else 
        skip = MAP(2 + n + 3 + 2);
    used_n = jit_save_regs_call(jit_info, interpreter, skip);
=====================================================================
Found a 21 line (143 tokens) duplication in the following files: 
Starting at line 249 of /home/juanjose/projects/parrot-bleed/src/byteorder.c
Starting at line 270 of /home/juanjose/projects/parrot-bleed/src/byteorder.c
fetch_buf_be_12(unsigned char *rb, unsigned char *b)
{
#if PARROT_BIGENDIAN
    memcpy(rb, b, 12);
#else
    rb[0] = b[11];
    rb[1] = b[10];
    rb[2] = b[9];
    rb[3] = b[8];
    rb[4] = b[7];
    rb[5] = b[6];
    rb[6] = b[5];
    rb[7] = b[4];
    rb[8] = b[3];
    rb[9] = b[2];
    rb[10] = b[1];
    rb[11] = b[0];
#endif
}

void
=====================================================================
Found a 21 line (142 tokens) duplication in the following files: 
Starting at line 28 of /home/juanjose/projects/parrot-bleed/src/jit/arm/exec_dep.h
Starting at line 951 of /home/juanjose/projects/parrot-bleed/src/jit/arm/jit_emit.h
Parrot_jit_normal_op(Parrot_jit_info_t *jit_info,
                     Interp * interpreter)
{
    jit_info->native_ptr = emit_mov (jit_info->native_ptr, r1, r4);
#ifndef ARM_K_BUG
    jit_info->native_ptr = emit_mov (jit_info->native_ptr, REG14_lr, REG15_pc);
    jit_info->native_ptr = emit_ldmstm (jit_info->native_ptr,
                                        cond_AL, is_load, dir_IA,
                                        is_writeback,
                                        REG14_lr,
                                        reg2mask(0) | reg2mask(REG15_pc));
#else
    jit_info->native_ptr = emit_arith_immediate (jit_info->native_ptr, cond_AL,
                                                 ADD, 0, REG14_lr, REG15_pc,
                                                 4, 0);
    jit_info->native_ptr = emit_ldmstm (jit_info->native_ptr,
                                        cond_AL, is_load, dir_IA,
                                        is_writeback,
                                        REG14_lr,
                                        reg2mask(0) | reg2mask(REG12_ip));
    jit_info->native_ptr = emit_mov (jit_info->native_ptr, REG15_pc, REG12_ip);
=====================================================================
Found a 28 line (141 tokens) duplication in the following files: 
Starting at line 204 of /home/juanjose/projects/parrot-bleed/src/encodings/utf16.c
Starting at line 461 of /home/juanjose/projects/parrot-bleed/src/encodings/utf8.c
    return_string->bufused = count;

    return_string->strlen = count;
    return_string->hashval = 0;

    return return_string;
}


static STRING *
get_codepoints_inplace(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count, STRING *return_string)
{
    String_iter iter;
    UINTVAL start;
    Parrot_reuse_COW_reference(interpreter, src, return_string);
    iter_init(interpreter, src, &iter);
    iter.set_position(interpreter, &iter, offset);
    start = iter.bytepos;
    return_string->strstart = (char *)return_string->strstart + start ;
    iter.set_position(interpreter, &iter, offset + count);
    return_string->bufused = iter.bytepos - start;
    return_string->strlen = count;
    return_string->hashval = 0;
    return return_string;
}

static STRING *
=====================================================================
Found a 22 line (129 tokens) duplication in the following files: 
Starting at line 25 of /home/juanjose/projects/parrot-bleed/src/jit/i386/exec_dep.h
Starting at line 3524 of /home/juanjose/projects/parrot-bleed/src/jit/i386/jit_emit.h
    int last_is_branch = 0;
    void ** offset;
    extern PARROT_API char **Parrot_exec_rel_addr;
    extern PARROT_API int Parrot_exec_rel_count;

    assert(op_jit[*jit_info->cur_op].extcall == 1);
    if (cur_section->done == 1)
        return;
    else if (cur_section->done == -1 && --cur_section->ins_count > 0)
        return;
    /* check, where section ends
     */
    if (interpreter->op_info_table[*cur_section->end].jump)
        last_is_branch = 1;
    else if (cur_section->next && !cur_section->next->isjit)
        last_is_branch = 1;
    /* if more then 1 op, then jump to CGP, branches are never
     * executed in CGP, they are handled below */
    if (cur_section->done >= 0 &&
            (INTVAL)cur_section->op_count >= 2 + last_is_branch) {
        int saved = 0;
        offset = (jit_info->cur_op - interpreter->code->base.data) +
=====================================================================
Found a 23 line (128 tokens) duplication in the following files: 
Starting at line 113 of /home/juanjose/projects/parrot-bleed/src/byteorder.c
Starting at line 138 of /home/juanjose/projects/parrot-bleed/src/byteorder.c
fetch_op_le(opcode_t w)
{
#if !PARROT_BIGENDIAN
    return w;
#else
#  if OPCODE_T_SIZE == 4
    return (w << 24) | ((w & 0x0000ff00) << 8) | ((w & 0x00ff0000) >> 8) |
        ((w & 0xff000000) >> 24);
#  else
    opcode_t r;

    r = w << 56;
    r |= (w & 0xff00) << 40;
    r |= (w & 0xff0000) << 24;
    r |= (w & 0xff000000) << 8;
    r |= (w & 0xff00000000) >> 8;
    r |= (w & 0xff0000000000) >> 24;
    r |= (w & 0xff000000000000) >> 40;
    r |= (w & 0xff00000000000000) >> 56;
    return r;
#  endif
#endif
}
=====================================================================
Found a 24 line (124 tokens) duplication in the following files: 
Starting at line 2530 of /home/juanjose/projects/parrot-bleed/src/bignum.c
Starting at line 2559 of /home/juanjose/projects/parrot-bleed/src/bignum.c
            if (!result->sign) {
                if (BN_getd(result, 0) != 0 ||
                    !BN_is_zero(PINT_ result, context)) {
                    BN_nonfatal(PINT_ context, BN_INEXACT,
                                "Loss of precision in divide");
                }
                BN_round_down(PINT_ result, context);
            }
            else if (BN_getd(result, 0) != 0) {
                BN_nonfatal(PINT_ context, BN_INEXACT,
                            "Loss of precision in divide");
                BN_round_up(PINT_ result, context);
            }
            else if (!BN_is_zero(PINT_ rem, context)) {
                BN_nonfatal(PINT_ context, BN_INEXACT,
                            "Loss of precision in divide");
                BN_round_up(PINT_ result, context);
            }
            else {
                BN_round_down(PINT_ result, context);
            }
        }
    }
    else { /* Other roundings just need digits to play with */
=====================================================================
Found a 21 line (124 tokens) duplication in the following files: 
Starting at line 43 of /home/juanjose/projects/parrot-bleed/src/byteorder.c
Starting at line 78 of /home/juanjose/projects/parrot-bleed/src/byteorder.c
fetch_iv_be(INTVAL w)
{
#if PARROT_BIGENDIAN
    return w;
#else
#  if INTVAL_SIZE == 4
    return (w << 24) | ((w & 0xff00) << 8) | ((w & 0xff0000) >> 8) | (w >> 24);
#  else
    INTVAL r;
    r = w << 56;
    r |= (w & 0xff00) << 40;
    r |= (w & 0xff0000) << 24;
    r |= (w & 0xff000000) << 8;
    r |= (w & 0xff00000000) >> 8;
    r |= (w & 0xff0000000000) >> 24;
    r |= (w & 0xff000000000000) >> 40;
    r |= (w & 0xff00000000000000) >> 56;
    return r;
#  endif
#endif
}
=====================================================================
Found a 41 line (119 tokens) duplication in the following files: 
Starting at line 231 of /home/juanjose/projects/parrot-bleed/src/encodings/utf16.c
Starting at line 127 of /home/juanjose/projects/parrot-bleed/src/encodings/ucs2.c
	UINTVAL offset, UINTVAL count, STRING *dest_string)
{

    UNIMPL;
    return NULL;
}

static STRING *
get_bytes_inplace(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count, STRING *return_string)
{
    UNIMPL;
    return NULL;
}

static void
set_codepoints(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count, STRING *new_codepoints)
{
    UNIMPL;
}

static void
set_bytes(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count, STRING *new_bytes)
{
    UNIMPL;
}

/* Unconditionally makes the string be in this encoding, if that's
   valid */
static void
become_encoding(Interp *interpreter, STRING *src)
{
    UNIMPL;
}


static UINTVAL
codepoints(Interp *interpreter, STRING *src)
{
=====================================================================
Found a 21 line (119 tokens) duplication in the following files: 
Starting at line 444 of /home/juanjose/projects/parrot-bleed/src/charset/unicode.c
Starting at line 482 of /home/juanjose/projects/parrot-bleed/src/charset/unicode.c
find_not_cclass(Interp *interpreter, PARROT_CCLASS_FLAGS flags, STRING *source_string, UINTVAL offset, UINTVAL count)
{
    UINTVAL pos = offset;
    UINTVAL end = offset + count;
    UINTVAL codepoint;
#if PARROT_HAS_ICU
    int bit, mask;
#endif

    assert(source_string != 0);
    end = source_string->strlen < end ? source_string->strlen : end;
    for (; pos < end; ++pos) {
        codepoint = ENCODING_GET_CODEPOINT(interpreter, source_string, pos);
        if (codepoint >= 256) {
#if PARROT_HAS_ICU
            for (mask = enum_cclass_uppercase;
                    mask <= enum_cclass_word ; mask <<= 1) {
                bit = mask & flags;
                if (!bit)
                    continue;
                if (!is_foo(interpreter, codepoint, bit))
=====================================================================
Found a 26 line (115 tokens) duplication in the following files: 
Starting at line 2317 of /home/juanjose/projects/parrot-bleed/src/jit/i386/jit_emit.h
Starting at line 2386 of /home/juanjose/projects/parrot-bleed/src/jit/i386/jit_emit.h
        jit_emit_mov_RM_i(NATIVECODE, emit_ECX, ROFFS_INT(2));
    }
    /*  range check */
    jit_emit_cmp_ri_i(NATIVECODE, emit_ECX, 0);
    L2 = NATIVECODE;
    emitm_jxs(NATIVECODE, emitm_js, 0);
    emitm_movl_m_r(NATIVECODE, emit_EAX, emit_EDI, 0, 1,
            offsetof(struct pobj_t, u._i._int_val));
    jit_emit_cmp_rr_i(NATIVECODE, emit_ECX, emit_EAX);
    L3 = NATIVECODE;
    emitm_jxs(NATIVECODE, emitm_jnl, 0);

    /*
     * mov (pmc_ext)%edi, %eax
     * mov (data)%eax, %eax
     * mov $3, %edx
     * mov $edx, (%eax, %ecx, 4)
     * jmp L4
     */
#  if ! PMC_DATA_IN_EXT
#error "todo"
#else
    emitm_movl_m_r(NATIVECODE, emit_EAX, emit_EDI, 0, 1,
            offsetof(struct PMC, pmc_ext));
    emitm_movl_m_r(NATIVECODE, emit_EAX, emit_EAX, 0, 1,
            offsetof(struct PMC_EXT, data));
=====================================================================
Found a 19 line (114 tokens) duplication in the following files: 
Starting at line 1710 of /home/juanjose/projects/parrot-bleed/src/jit/i386/jit_emit.h
Starting at line 1749 of /home/juanjose/projects/parrot-bleed/src/jit/i386/jit_emit.h
mod_rr_n(Parrot_jit_info_t *jit_info, int r)
{
    char *L1;
    static const char* div_by_zero = "Divide by zero";
    char *pc = jit_info->native_ptr;

    jit_emit_test_r_n(pc, (char)0);   /* TOS */
    L1 = pc;
    emitm_jxs(pc, emitm_jnz, 0);
    emitm_pushl_i(pc, div_by_zero);
    emitm_pushl_i(pc, E_ZeroDivisionError);
    emitm_pushl_i(pc, 0);    /* NULL */
    Parrot_jit_emit_get_INTERP(pc, emit_ECX);
    emitm_pushl_r(pc, emit_ECX);
    jit_info->native_ptr = pc;
    call_func(jit_info, (void*) real_exception);
    pc = jit_info->native_ptr;
    /* L1: */
    L1[1] = pc - L1 - 2;
=====================================================================
Found a 37 line (113 tokens) duplication in the following files: 
Starting at line 485 of /home/juanjose/projects/parrot-bleed/src/encodings/utf8.c
Starting at line 131 of /home/juanjose/projects/parrot-bleed/src/encodings/ucs2.c
    return NULL;
}

static STRING *
get_bytes_inplace(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count, STRING *return_string)
{
    UNIMPL;
    return NULL;
}

static void
set_codepoints(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count, STRING *new_codepoints)
{
    UNIMPL;
}

static void
set_bytes(Interp *interpreter, STRING *src,
	UINTVAL offset, UINTVAL count, STRING *new_bytes)
{
    UNIMPL;
}

/* Unconditionally makes the string be in this encoding, if that's
   valid */
static void
become_encoding(Interp *interpreter, STRING *src)
{
    UNIMPL;
}


static UINTVAL
codepoints(Interp *interpreter, STRING *src)
{
=====================================================================
Found a 18 line (112 tokens) duplication in the following files: 
Starting at line 708 of /home/juanjose/projects/parrot-bleed/src/jit/ppc/jit_emit.h
Starting at line 741 of /home/juanjose/projects/parrot-bleed/src/jit/ppc/jit_emit.h
    jit_emit_cmp_rr_n(pc, B, f1);   /* XXX be sure it's unmapped */
     /* remember PC */
    jmp_ptr = pc;
    /* emit jump past exception code, dummy offset */
    _emit_bc(pc, BNE, 0, 0, 0);
    jit_emit_mov_rr(pc, r3, r16); /* interp */
    jit_emit_mov_ri_i(pc, r4, 0);          /* NULL */
    jit_emit_mov_ri_i(pc, r5, E_ZeroDivisionError);          /* type */
    jit_emit_mov_ri_i(pc, r6, div_by_zero); 
    jit_info->native_ptr = pc;
    jit_emit_call_func(pc, (void*) real_exception);
    pc = jit_info->native_ptr;
    /* fixup above jump */
    sav_ptr = pc;
    pc = jmp_ptr;
    _emit_bc(pc, BNE, ((long)(sav_ptr - jmp_ptr)), 0, 0);
    /* restore PC */
    pc = sav_ptr;
=====================================================================
Found a 18 line (111 tokens) duplication in the following files: 
Starting at line 2454 of /home/juanjose/projects/parrot-bleed/src/bignum.c
Starting at line 2688 of /home/juanjose/projects/parrot-bleed/src/bignum.c
                    "division by zero in divide-integer");
        BN_set_inf(PINT_ result);
        result->sign = 1 & (one->sign ^ two->sign);
        return;
    }

    /* We're left with the case that only arg 1 is zero */
    if (BN_is_zero(PINT_ one, context) ) {
        result->expn = 0;
        result->digits = 1;
        BN_setd(result, 0 ,0);
        result->sign = 1 & (one->sign ^ two->sign);
        return;
    }
    
    rem = BN_new(PINT_ 1);
    BN_arith_setup(PINT_ result, one, two, context, NULL);
    BN_idivide(PINT_ result, one, two, context, BN_DIV_DIVINT, rem);
=====================================================================
Found a 11 line (108 tokens) duplication in the following files: 
Starting at line 5053 of /home/juanjose/projects/parrot-bleed/src/malloc.c
Starting at line 5273 of /home/juanjose/projects/parrot-bleed/src/malloc.c
        result = g_last->top_allocated;
    }
    /* Assert invariants */
    assert (g_last);
    assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
            g_last->top_allocated <= g_last->top_committed);
    assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
            g_last->top_committed <= g_last->top_reserved &&
            (unsigned) g_last->top_committed % g_pagesize == 0);
    assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
    assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
=====================================================================
Found a 30 line (106 tokens) duplication in the following files: 
Starting at line 740 of /home/juanjose/projects/parrot-bleed/src/list.c
Starting at line 2175 of /home/juanjose/projects/parrot-bleed/src/malloc.c
  if (x >= 0x10000) return NBINS-1;

  /* On intel, use BSRL instruction to find highest bit */
#if defined(__GNUC__) && defined(i386)

  __asm__("bsrl %1,%0\n\t"
          : "=r" (m) 
          : "g"  (x));

#else
  {
    /*
      Based on branch-free nlz algorithm in chapter 5 of Henry
      S. Warren Jr's book "Hacker's Delight".
    */

    unsigned int n = ((x - 0x100) >> 16) & 8;
    x <<= n; 
    m = ((x - 0x1000) >> 16) & 4;
    n += m; 
    x <<= m; 
    m = ((x - 0x4000) >> 16) & 2;
    n += m; 
    x = (x << m) >> 14;
    m = 13 - n + (x & ~(x>>1));
  }
#endif

  /* Use next 2 bits to create finer-granularity bins */
  return NSMALLBINS + (m << 2) + ((sz >> (m + 6)) & 3);
=====================================================================
Found a 14 line (104 tokens) duplication in the following files: 
Starting at line 698 of /home/juanjose/projects/parrot-bleed/src/inter_call.c
Starting at line 1037 of /home/juanjose/projects/parrot-bleed/src/inter_call.c
    switch (st->dest.sig & PARROT_ARG_TYPE_MASK) {
        case PARROT_ARG_INTVAL:
            CTX_REG_INT(st->dest.ctx, idx) = UVal_int(st->val);
            break;
        case PARROT_ARG_FLOATVAL:
            CTX_REG_NUM(st->dest.ctx, idx) = UVal_num(st->val);
            break;
        case PARROT_ARG_STRING:
            CTX_REG_STR(st->dest.ctx, idx) = UVal_str(st->val);
            break;
        case PARROT_ARG_PMC:
            CTX_REG_PMC(st->dest.ctx, idx) =  UVal_pmc(st->val);
            break;
    }
=====================================================================
Found a 17 line (103 tokens) duplication in the following files: 
Starting at line 215 of /home/juanjose/projects/parrot-bleed/src/byteorder.c
Starting at line 232 of /home/juanjose/projects/parrot-bleed/src/byteorder.c
fetch_buf_le_8(unsigned char *rb, unsigned char *b)
{
#if !PARROT_BIGENDIAN
    memcpy(rb, b, 8);
#else
    rb[0] = b[7];
    rb[1] = b[6];
    rb[2] = b[5];
    rb[3] = b[4];
    rb[4] = b[3];
    rb[5] = b[2];
    rb[6] = b[1];
    rb[7] = b[0];
#endif
}

void
=====================================================================
Found a 19 line (102 tokens) duplication in the following files: 
Starting at line 289 of /home/juanjose/projects/parrot-bleed/src/charset/iso-8859-1.c
Starting at line 385 of /home/juanjose/projects/parrot-bleed/src/charset/ascii.c
        if ((Parrot_ascii_typetable[codepoint] & flags) != 0) {
            return pos;
        }
    }
    return end;
}

static INTVAL
find_not_cclass(Interp *interpreter, PARROT_CCLASS_FLAGS flags, STRING *source_string, UINTVAL offset, UINTVAL count)
{
    UINTVAL pos = offset;
    UINTVAL end = offset + count;
    UINTVAL codepoint;

    assert(source_string != 0);
    end = source_string->strlen < end ? source_string->strlen : end;
    for (; pos < end; ++pos) {
	codepoint = ENCODING_GET_CODEPOINT(interpreter, source_string, pos);
        if ((Parrot_ascii_typetable[codepoint] & flags) == 0) {