Differential Information Content

Get info at indiv.

In order to look for genes with differential information content (dIC) between species, I need to create a method for calculating indiviudal level info content measures.

It will be like what I did previously but I will work with individual ratios rather than means. I will use python and wrap the code around each individual. I can make it in a long dataframe at first to write out the gene, individual, and values, then I can spread the output in R after.

It will take in the ratio file.

PASuse=read.table("../data/PAS_doubleFilter/PAS_5perc_either_HumanCoord_BothUsage_meta_doubleFilter.txt", stringsAsFactors = F ,header = T)

mkdir ../data/DoubleFilterUsageNumeric
mkdir ../data/IndInfoContent

Chimp usage:

ChimpAnno=read.table("../Chimp/data/phenotype/ALLPAS_postLift_LocParsed_Chimp_Pheno.txt", header = T, stringsAsFactors = F) %>% tidyr::separate(chrom, sep = ":", into = c("chr", "start", "end", "id")) %>% tidyr::separate(id, sep="_", into=c("gene", "strand", "peak"))  %>% separate(peak,into=c("loc", "disc","PAS"), sep="-")
IndC=colnames(ChimpAnno)[9:ncol(ChimpAnno)]

ChimpUsage=read.table("../Chimp/data/phenotype/ALLPAS_postLift_LocParsed_Chimp_Pheno_countOnlyNumeric.txt", col.names = IndC)
ChimpUsage_nuclear= ChimpUsage %>% select(contains("_N"))

ChimpUsage_anno=as.data.frame(cbind(ChimpAnno[,1:8],ChimpUsage_nuclear )) %>% filter(PAS %in% PASuse$PAS) %>% select(-chr, -start, -end, -strand, -loc, -disc)

Human Usage:

HumanAnno=read.table("../Human/data/phenotype/ALLPAS_postLift_LocParsed_Human_Pheno.txt", header = T, stringsAsFactors = F) %>% tidyr::separate(chrom, sep = ":", into = c("chr", "start", "end", "id")) %>% tidyr::separate(id, sep="_", into=c("gene", "strand", "peak"))  %>% separate(peak,into=c("loc", "disc","PAS"), sep="-")
IndH=colnames(HumanAnno)[9:ncol(HumanAnno)]

HumanUsage=read.table("../Human/data/phenotype/ALLPAS_postLift_LocParsed_Human_Pheno_countOnlyNumeric.txt", col.names = IndH)
HumanUsage_nuclear= HumanUsage %>% select(contains("_N"))

HumanUsage_anno=as.data.frame(cbind(HumanAnno[,1:8],HumanUsage_nuclear )) %>% filter(PAS %in% PASuse$PAS) %>% select(-chr, -start, -end, -strand, -loc, -disc)

bothUsage=HumanUsage_anno %>% inner_join(ChimpUsage_anno, by=c("gene","PAS"))

write.table(bothUsage,"../data/DoubleFilterUsageNumeric/BothSpecies_NumericUsage_DoubleFilt.txt", col.names = T, row.names = F, quote = F)

write.table(ChimpUsage_anno,"../data/DoubleFilterUsageNumeric/Chimp_NumericUsage_DoubleFilt.txt", col.names = T, row.names = F, quote = F)

write.table(HumanUsage_anno,"../data/DoubleFilterUsageNumeric/Human_NumericUsage_DoubleFilt.txt", col.names = T, row.names = F, quote = F)

bothUsage %>% select(gene) %>% unique() %>% nrow

[1] 9518

ChimpUsage_anno%>% group_by(gene) %>% summarise(nPAS=n()) %>% filter(nPAS>1) %>% nrow

[1] 8451

HumanUsage_anno %>% group_by(gene) %>% summarise(nPAS=n()) %>% filter(nPAS>1) %>% nrow

[1] 8451

test the code:

head ../data/DoubleFilterUsageNumeric/Human_NumericUsage_DoubleFilt.txt >  ../data/IndInfoContent/test.txt

python InfoContentbyInd.py ../data/IndInfoContent/test.txt ../data/IndInfoContent/testout.txt


head ../data/DoubleFilterUsageNumeric/BothSpecies_NumericUsage_DoubleFilt.txt >  ../data/IndInfoContent/bothtest.txt

python InfoContentbyInd.py ../data/IndInfoContent/bothtest.txt ../data/IndInfoContent/bothtestOut.txt

test=read.table("../data/IndInfoContent/testout.txt", col.names = c("gene", "ind", "shannon", "eq", "simpson"), stringsAsFactors = F)
testBoth=read.table("../data/IndInfoContent/bothtestOut.txt",col.names = c("gene", "ind", "shannon", "eq", "simpson"), stringsAsFactors = F)

Try it:

python InfoContentbyInd.py ../data/DoubleFilterUsageNumeric/Chimp_NumericUsage_DoubleFilt.txt  ../data/IndInfoContent/ChimpInfoContent_long.txt


python InfoContentbyInd.py ../data/DoubleFilterUsageNumeric/Human_NumericUsage_DoubleFilt.txt  ../data/IndInfoContent/HumanInfoContent_long.txt

chimpAllInfoLong=read.table("../data/IndInfoContent/ChimpInfoContent_long.txt", col.names = c("gene", "ind", "shannon", "eq", "simpson"), stringsAsFactors = F ) %>% mutate(species="Chimp")

humanAllInfoLong=read.table("../data/IndInfoContent/HumanInfoContent_long.txt", col.names = c("gene", "ind", "shannon", "eq", "simpson"), stringsAsFactors = F )%>% mutate(species="Human")

Simpson

Spread the simpson to do differences between species:

humanSimp= humanAllInfoLong %>% select(-eq,-shannon,- species) %>% spread(ind, simpson)

chimpSimp= chimpAllInfoLong %>% select(-eq,-shannon,- species) %>% spread(ind, simpson)

BothSimp= chimpSimp %>% inner_join(humanSimp, by="gene")

design matrix:

humD=humanAllInfoLong %>% select(ind, species) %>% unique() 
chimpD=chimpAllInfoLong %>% select(ind, species) %>% unique()
design=bind_rows(chimpD,humD)
design$species=as.factor(design$species)
design

         ind species
1  NA18358_N   Chimp
2   NA3622_N   Chimp
3   NA3659_N   Chimp
4   NA4973_N   Chimp
5   NApt30_N   Chimp
6   NApt91_N   Chimp
7  NA18498_N   Human
8  NA18502_N   Human
9  NA18504_N   Human
10 NA18510_N   Human
11 NA18523_N   Human

Run some QC on this like we would be DE.

SimpMatric=BothSimp %>% column_to_rownames(var="gene")

head(SimpMatric)

      NA18358_N NA3622_N NA3659_N NA4973_N NApt30_N NApt91_N NA18498_N
AAAS     0.4040   0.3946   0.3746   0.3230   0.4514   0.4604    0.3111
AACS     0.8836   0.8395   0.8026   0.7926   0.7709   0.8108    0.7730
AAGAB    0.8453   0.7533   0.7894   0.7611   0.7774   0.8319    0.8629
AAK1     0.8063   0.8478   0.5903   0.7695   0.7500   0.7399    0.8679
AAMDC    0.3755   0.3107   0.4371   0.3584   0.3435   0.3107    0.5360
AAR2     0.1832   0.1326   0.5818   0.4366   0.5095   0.4582    0.3420
      NA18502_N NA18504_N NA18510_N NA18523_N
AAAS     0.3322    0.6561    0.4865    0.7555
AACS     0.7676    0.7633    0.8509    0.7633
AAGAB    0.8744    0.9053    0.9470    0.8934
AAK1     0.8336    0.9200    0.9262    0.9064
AAMDC    0.4878    0.4655    0.6243    0.3102
AAR2     0.0966    0.5375    0.4679    0.5203

colors <- colorRampPalette(c(brewer.pal(9, "Blues")[1],brewer.pal(9, "Blues")[9]))(100)

pal <- c(brewer.pal(9, "Set1"), brewer.pal(8, "Set2"), brewer.pal(12, "Set3"))
labels <- paste(design$species,design$ind, sep=" ")

#PCA function (original code from Julien Roux)
#Load in the plot_scores function
plot_scores <- function(pca, scores, n, m, cols, points=F, pchs =20, legend=F){
  xmin <- min(scores[,n]) - (max(scores[,n]) - min(scores[,n]))*0.05
  if (legend == T){ ## let some room (35%) for a legend                                                                                                                                                 
    xmax <- max(scores[,n]) + (max(scores[,n]) - min(scores[,n]))*0.50
  }
  else {
    xmax <- max(scores[,n]) + (max(scores[,n]) - min(scores[,n]))*0.05
  }
  ymin <- min(scores[,m]) - (max(scores[,m]) - min(scores[,m]))*0.05
  ymax <- max(scores[,m]) + (max(scores[,m]) - min(scores[,m]))*0.05
  plot(scores[,n], scores[,m], xlab=paste("PC", n, ": ", round(summary(pca)$importance[2,n],3)*100, "% variance explained", sep=""), ylab=paste("PC", m, ": ", round(summary(pca)$importance[2,m],3)*100, "% variance explained", sep=""), xlim=c(xmin, xmax), ylim=c(ymin, ymax), type="n")
  if (points == F){
    text(scores[,n],scores[,m], rownames(scores), col=cols, cex=1)
  }
  else {
    points(scores[,n],scores[,m], col=cols, pch=pchs, cex=1.3)
  }
}

# Clustering (original code from Julien Roux)
cors <- cor(SimpMatric, method="spearman", use="pairwise.complete.obs")

Correaltion plot

heatmap.2( cors, scale="none", col = colors, margins = c(12, 12), trace='none', denscol="white", labCol=labels,ColSideColors=pal[as.integer(as.factor(design$species))], cexCol = 0.2 + 1/log10(15), cexRow = 0.2 + 1/log10(15))

Past versions of unnamed-chunk-17-1.png

PCA:

# Perform PCA

pca_genes <- prcomp(t(SimpMatric), scale = F)
scores <- pca_genes$x


#Make PCA plots with the factors colored by species

### PCs 1 and 2 Raw Data
for (n in 1:1){
  col.v <- pal[as.integer(design$species)]
  plot_scores(pca_genes, scores, n, n+1, col.v)
}

Past versions of unnamed-chunk-18-1.png

plotDensities(SimpMatric, col=pal[as.numeric(design$species)], legend="topleft")

Past versions of unnamed-chunk-19-1.png

First pass I will just run a wilcoxan test and correct the pvalues.

BothSimpM=as.matrix(SimpMatric)
outPut=as.data.frame(cbind(gene=BothSimp$gene, pval=rep(0,nrow(BothSimp)), effect=rep(0,nrow(BothSimp))))
outPut$pval=as.numeric(as.character(outPut$pval))
outPut$effect=as.numeric(as.character(outPut$effect))
for (i in seq(1:nrow(BothSimp))){
  chimp=as.vector(BothSimpM[i,1:6])
  human=as.vector(BothSimpM[i,7:11])
  pval=wilcox.test(human, chimp, alt = "two.sided", paired=F)$p.value
  #effect=wilcoxonR(x =as.vector(BothSimpM[i,1:11]),  g = design$species)
  outPut[i,2] <- pval
  #outPut[i,3] <- effect
}

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

Warning in wilcox.test.default(human, chimp, alt = "two.sided", paired =
F): cannot compute exact p-value with ties

padj=p.adjust(outPut$pval, method ="fdr")
#plot(sort(padj))



outPutad=outPut %>% mutate(fdr=padj)

outPutadSig= outPutad %>% filter(fdr<0.05)

Plot pvalues:

plot(sort(outPutad$pval))

Past versions of unnamed-chunk-22-1.png

plot(sort(outPutad$fdr))

Past versions of unnamed-chunk-22-2.png

Look at mean and variance:

humanSimp= humanAllInfoLong %>% dplyr::select(-eq,-shannon)
chimpSimp= chimpAllInfoLong %>% dplyr::select(-eq,-shannon)

BothSimplong=humanSimp %>% bind_rows(chimpSimp)

SimpMeanVar= BothSimplong %>% group_by(species, gene) %>% summarise(mean=mean(simpson), var=var(simpson))

ggplot(SimpMeanVar, aes(y=mean, x=species))+ geom_boxplot()

ggplot(SimpMeanVar, aes(y=var, x=species))+ geom_boxplot()

SimpMeanVar= BothSimplong %>% group_by(species, gene) %>% summarise(mean=mean(simpson)) %>% spread(species, mean)
SimpHuman=read.table("../data/InfoContent/Human_SimpsonInfoContent.txt", header = T, stringsAsFactors = F) %>% rename(simpson_Human=simpson) %>% mutate(simpOpp_Human=1-simpson_Human)
SimpChimp=read.table("../data/InfoContent/Chimp_SimpsonInfoContent.txt", header = T, stringsAsFactors = F)%>% rename(simpson_Chimp=simpson)%>% mutate(simpOpp_Chimp=1-simpson_Chimp)

BothSimp= SimpHuman %>% inner_join(SimpChimp, by=c("gene", "numPAS")) %>% filter(numPAS > 1)



allSImpson=BothSimp %>% inner_join(SimpMeanVar, by="gene")

cor.test(allSImpson$simpOpp_Human, allSImpson$Human)

    Pearson's product-moment correlation

data:  allSImpson$simpOpp_Human and allSImpson$Human
t = 1046.8, df = 8449, p-value < 2.2e-16
alternative hypothesis: true correlation is not equal to 0
95 percent confidence interval:
 0.9960004 0.9963268
sample estimates:
     cor 
0.996167 

cor.test(allSImpson$simpOpp_Chimp, allSImpson$Chimp)

    Pearson's product-moment correlation

data:  allSImpson$simpOpp_Chimp and allSImpson$Chimp
t = 516.27, df = 8449, p-value < 2.2e-16
alternative hypothesis: true correlation is not equal to 0
95 percent confidence interval:
 0.9838485 0.9851593
sample estimates:
      cor 
0.9845177 

Explore the genes:

#outPutadSig
allSImpson_sig=allSImpson %>% mutate(sIC=ifelse(gene %in% outPutadSig$gene, "Yes","No"))


ggplot(allSImpson_sig, aes(x=Human, y=Chimp, col=sIC)) + geom_point()

ggplot(allSImpson_sig, aes(x=Human, y=Chimp, col=sIC)) + geom_density_2d()

Ok this makes sense. Let me look at medians.

SimpMed= BothSimplong %>% group_by(species, gene) %>% summarise(Median=median(simpson)) %>% spread(species, Median)

allSImpsonMed=BothSimp %>% inner_join(SimpMed, by="gene") %>% mutate(sIC=ifelse(gene %in% outPutadSig$gene, "Yes","No"))


ggplot(allSImpsonMed, aes(x=Human, y=Chimp, col=sIC)) + geom_point()

ggplot(allSImpsonMed, aes(x=Human, y=Chimp, col=sIC)) + geom_density_2d()

allSImpsonMed %>% group_by(sIC) %>% summarise(n=n())

# A tibble: 2 x 2
  sIC       n
  <chr> <int>
1 No     7570
2 Yes     881

Write out to look at overlap with phenotypes

write.table(allSImpsonMed,"../data/IndInfoContent/SimpsonMedianSignificance.txt", col.names = T, row.names = F, quote=F)

Session information

sessionInfo()

R version 3.5.1 (2018-07-02)
Platform: x86_64-pc-linux-gnu (64-bit)
Running under: Scientific Linux 7.4 (Nitrogen)

Matrix products: default
BLAS/LAPACK: /software/openblas-0.2.19-el7-x86_64/lib/libopenblas_haswellp-r0.2.19.so

locale:
 [1] LC_CTYPE=en_US.UTF-8       LC_NUMERIC=C              
 [3] LC_TIME=en_US.UTF-8        LC_COLLATE=en_US.UTF-8    
 [5] LC_MONETARY=en_US.UTF-8    LC_MESSAGES=en_US.UTF-8   
 [7] LC_PAPER=en_US.UTF-8       LC_NAME=C                 
 [9] LC_ADDRESS=C               LC_TELEPHONE=C            
[11] LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C       

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
 [1] RColorBrewer_1.1-2 gplots_3.0.1       scales_1.0.0      
 [4] rcompanion_2.1.1   R.utils_2.7.0      R.oo_1.22.0       
 [7] R.methodsS3_1.7.1  coin_1.3-0         survival_2.43-1   
[10] edgeR_3.24.0       limma_3.38.2       forcats_0.3.0     
[13] stringr_1.3.1      dplyr_0.8.0.1      purrr_0.3.2       
[16] readr_1.3.1        tidyr_0.8.3        tibble_2.1.1      
[19] ggplot2_3.1.1      tidyverse_1.2.1   

loaded via a namespace (and not attached):
 [1] nlme_3.1-137       bitops_1.0-6       matrixStats_0.54.0
 [4] fs_1.3.1           lubridate_1.7.4    httr_1.3.1        
 [7] rprojroot_1.3-2    tools_3.5.1        backports_1.1.2   
[10] utf8_1.1.4         R6_2.3.0           KernSmooth_2.23-15
[13] nortest_1.0-4      lazyeval_0.2.1     colorspace_1.3-2  
[16] withr_2.1.2        tidyselect_0.2.5   compiler_3.5.1    
[19] git2r_0.26.1       cli_1.1.0          rvest_0.3.2       
[22] expm_0.999-3       xml2_1.2.0         sandwich_2.5-0    
[25] labeling_0.3       caTools_1.17.1.1   lmtest_0.9-36     
[28] mvtnorm_1.0-8      multcompView_0.1-7 digest_0.6.18     
[31] foreign_0.8-71     rmarkdown_1.10     pkgconfig_2.0.2   
[34] htmltools_0.3.6    manipulate_1.0.1   rlang_0.4.0       
[37] readxl_1.1.0       rstudioapi_0.10    generics_0.0.2    
[40] zoo_1.8-4          jsonlite_1.6       gtools_3.8.1      
[43] magrittr_1.5       modeltools_0.2-22  Matrix_1.2-15     
[46] fansi_0.4.0        Rcpp_1.0.4.6       DescTools_0.99.28 
[49] munsell_0.5.0      stringi_1.2.4      multcomp_1.4-8    
[52] whisker_0.3-2      yaml_2.2.0         MASS_7.3-51.1     
[55] plyr_1.8.4         grid_3.5.1         parallel_3.5.1    
[58] gdata_2.18.0       promises_1.0.1     crayon_1.3.4      
[61] lattice_0.20-38    haven_1.1.2        splines_3.5.1     
[64] hms_0.4.2          locfit_1.5-9.1     knitr_1.20        
[67] pillar_1.3.1       EMT_1.1            boot_1.3-20       
[70] codetools_0.2-15   stats4_3.5.1       glue_1.3.0        
[73] evaluate_0.12      modelr_0.1.2       httpuv_1.4.5      
[76] cellranger_1.1.0   gtable_0.2.0       assertthat_0.2.0  
[79] libcoin_1.0-4      broom_0.5.1        later_0.7.5       
[82] workflowr_1.6.0    TH.data_1.0-9