final double[] sortedLikelihoods = new double[sortedHaplotypes.size()];

            unsorted.loadRead(read);

            sorted.loadRead(read);

            for (int i = 0; i < sortedHaplotypes.size(); i++) {

                final byte[] haplotypeBases2 = haplotypeBases.clone();

                int commonPrefixEnd = 0;

                if (lastHaplotypeBases != null) {

        Assert.assertEquals(haplotypes.size(),(int) Math.pow(2,variants));

        final Map<String,Integer> haplotypeNumberByString = new HashMap<>();

        for (int i = 0; i < haplotypes.size(); i++) {

            final Civar civar = haplotypeCivars.get(i);

            if (i == 0) {

            } else {

            }

        }

        final int[] hapReadsNotInReference = new int[haplotypes.size()];

        for (int i = 0; i < readCount; i++) {

        haplotypeRouteByHaplotype = new LinkedHashMap<>(haplotypes.size());

        final Iterator<Haplotype> haplotypeIterator = haplotypes.iterator();

        final Set<Haplotype> nonFoundHaplotypes = new HashSet<>(haplotypes.size());

        while (haplotypeIterator.hasNext()) {

            final HaplotypeRoute haplotypeRoute = buildHaplotypeRoute(haplotype);

            if (haplotypeRoute == null) {

                haplotypeIterator.remove();

                nonFoundHaplotypes.add(haplotype);

                    referenceHaplotype = null;

                    referenceRoute = null;

                    referenceVertices = Collections.emptySet();

                    referenceBases = null;

                }

            } else {

                    referenceHaplotype = haplotype;

                    referenceRoute = haplotypeRoute;

                    referenceVertices = haplotypeRoute.vertexSet();

                    referenceBases = haplotypeRoute.getBases();

                }

     * @return never {@code null}.

     */

    public Haplotype haplotype() {

        if (haplotype != null) return haplotype;

        if (score() > 0)

            throw new IllegalStateException("score cannot be greater than 0: " + score());

        haplotype.setScore(score());

        return haplotype;

    }

        test.haplotypes = haplotypes;

        batchRequests.add(test);

        for (int jjj = 0; jjj < numHaplotypes; jjj++) {

            final boolean recacheReadValues = (jjj == 0);

                throw new RuntimeException("FPGA queue overflow in batchAdd");

        }

    }

        results = new double[numHaplotypes];

        for (int jjj = 0; jjj < numHaplotypes; jjj++) {

            results[jjj] = resultQueue.pop();

            if (results[jjj]<-60.0) {

            }

        }

        return results;

    }

        final LinkedHashMap<Allele, Haplotype> trimmedHaplotypeMap = new LinkedHashMap<>();

        for (final Allele a: haplotypeMap.keySet()) {

            if ( indStart >= indStop )

                continue;

            // commented out here because we need to make this method static for unit testing

            //if (DEBUG)

            //    System.out.format("indStart: %d indStop: %d WinStart:%d WinStop:%d start: %d stop: %d\n",

            //            indStart, indStop, ref.getWindow().getStart(), ref.getWindow().getStop(), startLocationInRefForHaplotypes, stopLocationInRefForHaplotypes);

            // get the trimmed haplotype-bases array and create a new haplotype based on it. Pack this into the new map

            trimmedHaplotypeMap.put(a, trimmedHaplotype);

        }

        return trimmedHaplotypeMap;

    }

                    pairHMM.computeLikelihoods(rl.sampleMatrix(0), Collections.singletonList(processedRead), readGCPArrayMap);

                    // Pack the original pilup element, each allele, and each associated log10 likelihood into a final map, and add each likelihood to the array

                    for (final Allele a: trimmedHaplotypeMap.keySet()){

                        final int hIndex = rl.alleleIndex(h);

                        final double readLikelihood = dummySampleLikelihoods.get(hIndex,0);

                        readLikelihoods[readIdx][j++] = readLikelihood;

                        perReadAlleleLikelihoodMap.add(p,a,readLikelihood);

                    }

    @Test

    public void trimHaplotypesToNullAlleleTest() {

        // we need a case where start and stop > haplotype coordinates

        final int start = 100, stop = 100;

  final Map<Allele, Haplotype> input = new HashMap<Allele, Haplotype>(1);

  input.put(Allele.create("A"), h);

  final Map<Allele, Haplotype> output = PairHMMIndelErrorModel.trimHaplotypes(input, start, stop, null);

        Assert.assertTrue(output.isEmpty());

        return read;

    }

    private Haplotype makeHaplotype(final String bases, final String cigar) {

        return hap;

    }