back that sh** up

RIVtoolsCPU.h

+#include <stdio.h>
+#include <stdlib.h>
+#include <strsafe.h>
+
+#define SEEDMASK 25214903917
+struct RIVData{
+	int RIVsize;
+	int nonZeros;
+	long long int *masks;
+	int *h_tempBlock;
+	int *h_stagingBlock;
+	int *h_staging_slider;
+	int *h_staging_stop;
+	int *h_displacements;
+	int *d_OpenSlot;
+	int *d_SlotEnd;
+	float *d_magnitudes;
+	int thing;
+}RIVKeyData;
+typedef struct{
+	char name[100];
+	int *values;
+	int *locations;
+	int count;
+	int frequency;
+	float magnitude;
+	int boolean;
+}sparseRIV;
+sparseRIV FileToL2(FILE *data);
+void consolidateD2S(sparseRIV *destination, int *denseInput);
+void setKeyData(int RIVsize, int nonZeros, int blockSize);
+int* mapS2D(int * destination, sparseRIV input);
+int* makeSparseLocations(int *seeds, int seedCount);
+void makeSeeds(unsigned char* word, int **seeds, int *seedCount);
+float* cosineCompare(sparseRIV baseRIV, sparseRIV *multipliers, int multiplierCount, float threshold);
+void getMagnitudes(sparseRIV *inputs, int RIVCount);
+int *mapI2D(int *locations, int seedCount);
+sparseRIV text2L2(unsigned char *text);
+unsigned char *sscanAdvance(unsigned char **string, unsigned char *word);
+
+
+  sparseRIV FileToL2(FILE *data){
+	
+	
+	unsigned char *word = (unsigned char*)calloc(2000, 1);
+	int *seeds = RIVKeyData.h_tempBlock;
+		
+	
+	int seedCount = 0;
+	
+	while(fscanf(data, "%s", word)){
+		
+		if(feof(data)){
+			break;
+		}
+		if(!(*word)){
+			break;
+		}
+		
+		makeSeeds(word, &seeds, &seedCount);
+		memset(word, 0, 2000);
+		
+	}
+	
+	int *locations = makeSparseLocations(seeds, seedCount);
+	//printf("mcshittles");
+	int *L2dense;
+	L2dense = mapI2D(locations, seedCount);
+	
+	sparseRIV output;
+	//printf("tits");
+	consolidateD2S( &output, L2dense);	
+	free(L2dense);
+	
+	output.boolean = 1;
+	RIVKeyData.thing++;
+	return output;
+	
+}
+
+
+float* cosineCompare(sparseRIV baseRIV, sparseRIV *multipliers, int multiplierCount, float threshold){
+
+	int *baseDenseRIV = RIVKeyData.h_tempBlock;
+	mapS2D(baseDenseRIV, baseRIV);
+	float *outputs = (float*)malloc((multiplierCount)* sizeof(float));
+	float *output_slider = outputs;
+	sparseRIV *multipliersStop = multipliers+multiplierCount;
+	float minsize = baseRIV.magnitude * .75;
+	float maxsize = baseRIV.magnitude * 1.25;
+	
+	while(multipliers<multipliersStop){
+		
+		if(((*multipliers).boolean) /*&& (((*multipliers).magnitude < maxsize) && ((*multipliers).magnitude > minsize))*/){
+			int dot = 0;
+			int *values = (*multipliers).values;
+			int *locations = (*multipliers).locations;
+			int *locations_Stop = locations+(*multipliers).count;
+			
+			while(locations<locations_Stop){
+				
+				dot += (*values)*(*(baseDenseRIV+(*locations)));
+				locations++;
+				values++;
+			}
+			*output_slider= dot/((baseRIV.magnitude)*((*multipliers).magnitude));
+			if(*output_slider>=threshold){
+				printf("%s\t%s\n%f\n", (*multipliers).name, baseRIV.name, *output_slider);
+				(*multipliers).boolean = 0;
+				//RIVKeyData.thing ++;
+			}
+		}
+		multipliers++;
+		output_slider++;
+	}
+	
+	return outputs;
+	
+	
+}
+
+void getMagnitudes(sparseRIV *inputs, int RIVCount){
+	for(int i=0; i<RIVCount; i++){
+		int temp = 0;
+		int *values = inputs[i].values;
+		int *values_stop = values+inputs[i].count;
+		while(values<values_stop){	
+			temp += (*values)*(*values);
+			values++;
+			
+		}
+		float magnitude = sqrt(temp);
+		inputs[i].magnitude = magnitude;
+		//printf("magnitude = %f, \n", magnitude);
+	}
+		
+
+}
+
+int* mapS2D(int* destination, sparseRIV input){
+	memset(destination, 0, RIVKeyData.RIVsize*sizeof(int));
+	
+	int *locations_slider = input.locations;
+	int *values_slider = input.values;
+	int *locations_stop = locations_slider+input.count;
+	
+	while(locations_slider<locations_stop){
+		destination[*locations_slider] = *values_slider;
+		locations_slider++;
+		values_slider++;
+	}
+	
+	//HANDLE_ERROR (cudaMemcpy (RIVKeyData.d_OpenSlot, destination, RIVKeyData.RIVsize*sizeof(int), cudaMemcpyHostToDevice));
+	return destination;
+}
+
+int* mapI2D(int *locations, int valueCount){
+	int *destination = (int*)calloc(RIVKeyData.RIVsize,sizeof(int));
+	int *locations_slider = locations;
+	int *locations_stop = locations_slider+valueCount;
+	int value = 1;
+	while(locations_slider<locations_stop){
+	
+		destination[*locations_slider] +=value;
+		locations_slider++;
+		value = (value == 1)? -1: 1;
+	}
+	
+	
+	return destination;
+}
+	
+	
+
+void consolidateD2S(sparseRIV *destination, int *denseInput){
+	int count = 0;
+	(*destination).locations = (int*) malloc(RIVKeyData.RIVsize*sizeof(int));
+	(*destination).values = (int*) malloc(RIVKeyData.RIVsize*sizeof(int));
+
+	for(int i=0; i<RIVKeyData.RIVsize; i++){
+		if(denseInput[i]){
+			(*destination).locations[count] = i;
+			(*destination).values[count] = denseInput[i];
+			count++;
+		}
+	}
+	destination->count = count;
+	(*destination).locations = (int*) realloc((*destination).locations, (*destination).count*sizeof(int));
+	(*destination).values = (int*) realloc((*destination).values, (*destination).count*sizeof(int));
+	
+}
+
+
+void setKeyData(int RIVsize, int nonZeros, int blockSize){
+	RIVKeyData.RIVsize = RIVsize;
+	if(nonZeros%2){
+		printf("your nonZeros must be an even number");
+		nonZeros++;
+		printf(", changed to %d", nonZeros);
+	}
+	RIVKeyData.nonZeros = nonZeros;
+	RIVKeyData.masks = (long long int*)malloc(nonZeros*sizeof(long long int));
+	
+	for(int i = 0; i<nonZeros; i++){
+		RIVKeyData.masks[i] = SEEDMASK>>(5*i);
+	}
+	RIVKeyData.h_tempBlock = (int*)malloc(blockSize*sizeof(int));
+	//RIVKeyData.h_stagingBlock = (int*)malloc(blockSize*sizeof(int));
+	//RIVKeyData.h_staging_slider = RIVKeyData.h_stagingBlock;
+	RIVKeyData.thing = 0;
+	
+}
+
+void makeSeeds(unsigned char* word,  int **seeds, int *seedCount){
+	
+	int i=0;
+	int seedbase = 0;
+	while(*word){
+		seedbase += (*(word))<<(i*5);
+		word++;
+		i++;
+		
+	}
+	int *seedTrack = (*seeds)+*seedCount;
+	for(i =0 ; i<RIVKeyData.nonZeros; i++){
+		
+		*seedTrack = (seedbase>>i)+(3*i);
+		seedTrack++;
+	
+	}
+	*seedCount+=RIVKeyData.nonZeros;
+	return;
+}
+int* makeSparseLocations(int* seeds, int seedCount){
+
+	int *locations = RIVKeyData.h_tempBlock;
+	int *locations_slider = locations;
+	int *seeds_stop = seeds+seedCount;
+	
+	long long int *mask = RIVKeyData.masks;
+	long long int *mask_stop = mask+RIVKeyData.nonZeros;
+	while(seeds<seeds_stop){
+		*locations_slider =(((*seeds)^(*mask)) & 2147483647) %(RIVKeyData.RIVsize);
+		mask++;
+		locations_slider++;
+		seeds++;
+		if(!(mask<mask_stop)) mask-=RIVKeyData.nonZeros;
+	}
+	
+		
+	return locations;
+}
+
+
+unsigned char *sscanAdvance(unsigned char **string, unsigned char *word){
+	unsigned char *word_slider = word;
+	
+	while(*(*string)){
+		if(*(*string) == ' ') {
+			(*string)++;
+		break;
+	}
+		*word_slider = *(*string);
+	word_slider++;
+	(*string)++;
+	}
+	*word_slider = 0;
+	
+	return word;
+}
+sparseRIV text2L2(unsigned char *text){
+	unsigned char *word = (unsigned char*)calloc(2000, 1);
+	int *seeds = ( int*)malloc(RIVKeyData.nonZeros*sizeof( int));
+	unsigned char *text_slider = text;	
+	
+	int seedCount = 0;
+
+	while(*text_slider){
+		sscanAdvance(&text_slider, word);
+		makeSeeds(word, &seeds, &seedCount);
+		memset(word, 0, 2000);
+		
+	}
+	
+	int *locations = makeSparseLocations(seeds, seedCount);
+	
+	int *L2dense;
+	L2dense = mapI2D(locations, seedCount);
+	free(locations);
+
+	sparseRIV output;
+	consolidateD2S(&output, L2dense);	
+
+	free(seeds);
+	return output;
+}

RIVtoolsCPUlinux.h

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#define SEEDMASK 25214903917
+struct RIVData{
+	int RIVsize;
+	int nonZeros;
+	long long int *masks;
+	int *h_tempBlock;
+	int *h_stagingBlock;
+	int *h_staging_slider;
+	int *h_staging_stop;
+	int *h_displacements;
+	int *d_OpenSlot;
+	int *d_SlotEnd;
+	float *d_magnitudes;
+	int thing;
+}RIVKey;
+typedef struct{
+	char name[100];
+	int *values;
+	int *locations;
+	int count;
+	int frequency;
+	float magnitude;
+	int boolean;
+}sparseRIV;
+typedef struct{
+	char name[100];
+	int *values;
+	int frequency;
+	float magnitude;
+}denseRIV;
+int lexPush(denseRIV RIVout);
+denseRIV lexPull(int *valuesOut, char* word);
+int isWordClean(char* word);
+int isLetter(char c);
+sparseRIV FileToL2(FILE *data);
+sparseRIV FileToL2Clean(FILE *data);
+sparseRIV consolidateD2S(int *denseInput);
+void setKeyData(int RIVsize, int nonZeros, int blockSize);
+int* mapS2D(int * destination, sparseRIV input);
+int* makeSparseLocations(int *seeds, int seedCount);
+void makeSeeds(unsigned char* word, int **seeds, int *seedCount);
+void cosineCompare(sparseRIV baseRIV, sparseRIV *multipliers, int multiplierCount, float threshold);
+void getMagnitudes(sparseRIV *inputs, int RIVCount);
+int *mapI2D(int *locations, int seedCount);
+sparseRIV text2L2(unsigned char *text);
+unsigned char *sscanAdvance(unsigned char **string, unsigned char *word);
+
+
+ sparseRIV FileToL2(FILE *data){
+	
+	
+	unsigned char word[2000] = {0};
+	int *seeds = RIVKey.h_tempBlock;
+		
+	
+	int seedCount = 0;
+	
+	while(fscanf(data, "%s", word)){
+		
+		if(feof(data)){
+			break;
+		}
+		if(!(*word)){
+			break;
+		}
+		
+		makeSeeds(word, &seeds, &seedCount);
+		
+	}
+	
+	int *locations = makeSparseLocations(seeds, seedCount);
+	
+	int *L2dense;
+	L2dense = mapI2D(locations, seedCount);
+	
+	
+	
+	sparseRIV output = consolidateD2S(L2dense);	
+	free(L2dense);
+	output.frequency = seedCount/RIVKey.nonZeros;
+	output.boolean = 1;
+	return output;
+}
+ sparseRIV FileToL2Clean(FILE *data){
+	
+		
+	unsigned char word[100] = {0};
+	int *seeds = RIVKey.h_tempBlock;
+		
+	
+	int seedCount = 0;
+	
+	while(fscanf(data, "%100s", word)){
+		
+		if(feof(data)){
+			break;
+		}
+		if(!(*word)){
+			break;
+		}
+		if(!isWordClean((char*)word)) continue;
+		makeSeeds(word, &seeds, &seedCount);
+	
+		
+	}
+	
+	int *locations = makeSparseLocations(seeds, seedCount);
+	
+	int *L2dense;
+	L2dense = mapI2D(locations, seedCount);
+	
+	
+	
+	sparseRIV output = consolidateD2S(L2dense);	
+	free(L2dense);
+	output.frequency = seedCount/RIVKey.nonZeros;
+	output.boolean = 1;
+	return output;
+}
+
+void cosineCompare(sparseRIV baseRIV, sparseRIV *multipliers, int multiplierCount, float threshold){
+	
+	int *baseDenseRIV = RIVKey.h_tempBlock;
+	mapS2D(baseDenseRIV, baseRIV);
+	float cosSim;
+	sparseRIV *multipliersStop = multipliers+multiplierCount;
+	float minsize = baseRIV.magnitude * .75;
+	float maxsize = baseRIV.magnitude * 1.25;
+	
+	while(multipliers<multipliersStop){
+		if(((*multipliers).boolean)/* && (((*multipliers).magnitude < maxsize) && ((*multipliers).magnitude > minsize))*/){
+			int dot = 0;
+			int *values = (*multipliers).values;
+			int *locations = (*multipliers).locations;
+			int *locations_Stop = locations+(*multipliers).count;
+			
+			while(locations<locations_Stop){
+				
+				dot += (*values)*(*(baseDenseRIV+(*locations)));
+				locations++;
+				values++;
+			}
+			cosSim= dot/((baseRIV.magnitude)*((*multipliers).magnitude));
+			//if(cosSim>=threshold){
+				printf("#######%s\t%s\n%f\n", (*multipliers).name, baseRIV.name, cosSim);
+				(*multipliers).boolean = 0;
+				RIVKey.thing ++;
+				scanf("%d", &RIVKey.thing);
+			//}
+		}
+		multipliers++;
+		
+	}
+	
+}
+
+void getMagnitudes(sparseRIV *inputs, int RIVCount){
+	for(int i=0; i<RIVCount; i++){
+		int temp = 0;
+		int *values = inputs[i].values;
+		int *values_stop = values+inputs[i].count;
+		while(values<values_stop){	
+			temp += (*values)*(*values);
+			values++;
+			
+		}
+		float magnitude = sqrt(temp);
+		inputs[i].magnitude = magnitude;
+		//printf("magnitude = %f, \n", magnitude);
+	}
+		
+
+}
+
+int* mapS2D(int* destination, sparseRIV input){
+	memset(destination, 0, RIVKey.RIVsize*sizeof(int));
+	
+	int *locations_slider = input.locations;
+	int *values_slider = input.values;
+	int *locations_stop = locations_slider+input.count;
+	
+	while(locations_slider<locations_stop){
+		destination[*locations_slider] = *values_slider;
+		locations_slider++;
+		values_slider++;
+	}
+	
+	return destination;
+}
+
+int* mapI2D(int *locations, int valueCount){
+	int *destination = (int*)calloc(RIVKey.RIVsize,sizeof(int));
+	int *locations_slider = locations;
+	int *locations_stop = locations_slider+valueCount;
+	int value = 1;
+	while(locations_slider<locations_stop){
+	
+		destination[*locations_slider] +=value;
+		locations_slider++;
+		value = (value == 1)? -1: 1;
+	}
+	
+	
+	return destination;
+}
+	
+	
+
+sparseRIV consolidateD2S(int *denseInput){
+	sparseRIV output;
+	output.count = 0;
+	int* locations = RIVKey.h_tempBlock;
+	int* values = RIVKey.h_tempBlock+RIVKey.RIVsize;
+	int* locations_slider = locations;
+	int* values_slider = values;
+	for(int i=0; i<RIVKey.RIVsize; i++){
+		if(denseInput[i]){
+			*(locations_slider++) = i;
+			*(values_slider++) = denseInput[i];
+			output.count++;
+		}
+	}
+	output.locations = (int*) malloc(output.count*sizeof(int));
+	memcpy(output.locations, locations, output.count*sizeof(int));
+	
+	output.values = (int*) malloc(output.count*sizeof(int));
+	memcpy(output.values, values, output.count*sizeof(int));
+	
+	return output;
+}
+
+
+void setKeyData(int RIVsize, int nonZeros, int blockSize){
+	RIVKey.RIVsize = RIVsize;
+	if(nonZeros%2){
+		printf("your nonZeros must be an even number");
+		nonZeros++;
+		printf(", changed to %d", nonZeros);
+	}
+	RIVKey.nonZeros = nonZeros;
+	RIVKey.masks = (long long int*)malloc(nonZeros*sizeof(long long int));
+	
+	for(int i = 0; i<nonZeros; i++){
+		RIVKey.masks[i] = SEEDMASK>>(5*i);
+	}
+	RIVKey.h_tempBlock = (int*)malloc(blockSize*sizeof(int));
+	RIVKey.h_stagingBlock = (int*)malloc(blockSize*sizeof(int));
+	RIVKey.h_staging_slider = RIVKey.h_stagingBlock;
+	RIVKey.thing = 0;
+	
+}
+
+void makeSeeds(unsigned char* word,  int **seeds, int *seedCount){
+	
+	int i=0;
+	int seedbase = 0;
+	while(*word){
+		seedbase += (*(word))<<(i*5);
+		word++;
+		i++;
+		
+	}
+	int *seedTrack = (*seeds)+*seedCount;
+	for(i =0 ; i<RIVKey.nonZeros; i++){
+		
+		*seedTrack = (seedbase>>i)+(3*i);
+		seedTrack++;
+	
+	}
+	*seedCount+=RIVKey.nonZeros;
+	return;
+}
+int* makeSparseLocations(int* seeds, int seedCount){
+
+	int *locations = RIVKey.h_tempBlock;
+	int *locations_slider = locations;
+	int *seeds_stop = seeds+seedCount;
+	
+	long long int *mask = RIVKey.masks;
+	long long int *mask_stop = mask+RIVKey.nonZeros;
+	while(seeds<seeds_stop){
+		*locations_slider =(((*seeds)^(*mask)) & 2147483647) %(RIVKey.RIVsize);
+		mask++;
+		locations_slider++;
+		seeds++;
+		if(!(mask<mask_stop)) mask-=RIVKey.nonZeros;
+	}
+	
+		
+	return locations;
+}
+
+
+unsigned char *sscanAdvance(unsigned char **string, unsigned char *word){
+	unsigned char *word_slider = word;
+	
+	while(*(*string)){
+		if((*(*string) == ' ')||(*(*string) == '\n')) {
+			(*string)++;
+			break;
+		}
+		*word_slider = *(*string);
+		word_slider++;
+		(*string)++;
+	}
+	*word_slider = 0;
+	
+	return word;
+}
+sparseRIV text2L2(unsigned char *text){
+	unsigned char word[2000] = {0};
+	int *seeds = RIVKey.h_tempBlock;
+	unsigned char *text_slider = text;	
+	
+	int seedCount = 0;
+
+	while(*text_slider){
+		sscanAdvance(&text_slider, word);
+		if(word[0]){
+			makeSeeds(word, &seeds, &seedCount);
+		}
+		
+	}
+	
+	int *locations = makeSparseLocations(seeds, seedCount);
+	
+	int *L2dense;
+	L2dense = mapI2D(locations, seedCount);
+	
+	sparseRIV output = consolidateD2S(L2dense);	
+	free(L2dense);
+
+	return output;
+}
+
+
+int isLetter(char c){
+	
+	if((c>96 && c<123)||(c == 32) || (c == '_')) return 1;
+	else return 0;
+}
+int isWordClean(char* word){
+	char *letter = word;
+	char *word_stop = word+99;
+	while(letter<word_stop){
+		if(!(*letter)) break;
+		if(!(isLetter(*letter))){
+			
+			return 0;
+		}
+		letter++;
+	}
+	return 1;
+		
+}
+denseRIV lexPull(int *valuesOut, char* word){
+	denseRIV output;
+	output.values = valuesOut;
+	char pathString[200];
+	FILE *lexWord;
+	sprintf(pathString, "lexicon/%s", word);
+	lexWord = fopen(pathString, "r+");
+	strcpy(output.name, word);
+	if(lexWord){
+		fscanf(lexWord, "%d,%f", &output.frequency, &output.magnitude);
+		int* values_slider = valuesOut;
+		int* values_stop = valuesOut+RIVKey.RIVsize;
+		while(values_slider<values_stop){
+			
+			fscanf(lexWord, ",%d", values_slider);
+			values_slider++;
+		}
+				
+		fclose(lexWord);
+	}else{
+		output.frequency = 0;
+		output.magnitude = 0;
+		memset(valuesOut, 0, RIVKey.RIVsize*sizeof(int));
+	}
+	
+	return output;
+}
+int lexPush(denseRIV RIVout){
+	
+	char pathString[1000] = {0};
+	strcpy(pathString, "lexicon");
+	strcat(pathString, "/");
+	strcat(pathString, RIVout.name);
+	//printf("%s\n", pathString);
+	FILE *lexWord = fopen(pathString, "w+");
+	if(!lexWord){
+		lexWord = fopen(pathString, "w+");
+		if(!lexWord){
+			printf("fucked it up big time bro, %s\n", pathString);
+			printf("%s\n", pathString);
+			return 1;
+		}
+	 }
+	 
+	//printf( "%f",RIVout.magnitude);
+	fprintf(lexWord, "%d,%f", RIVout.frequency, RIVout.magnitude);
+	int *values_slider = RIVout.values;
+	int *values_stop = RIVout.values+RIVKey.RIVsize;
+	while(values_slider<values_stop){
+		fprintf(lexWord, ",%d", *(values_slider));
+		values_slider++;
+	}
+	fclose(lexWord);
+	return 0;
+	
+	
+}
+

parsing/about

+1
\ No newline at end of file

parsing/absence

+1
\ No newline at end of file

parsing/accessible

+1
\ No newline at end of file

parsing/according

+1
\ No newline at end of file

parsing/acroteres

+0
\ No newline at end of file

parsing/admission

+1
\ No newline at end of file

parsing/advantagious

+1
\ No newline at end of file

parsing/advantagiously

+2advantagious
\ No newline at end of file

parsing/after

+1
\ No newline at end of file

parsing/again

+1
\ No newline at end of file

parsing/against

+1
\ No newline at end of file

parsing/agreable

+2agreeable
\ No newline at end of file

parsing/agreeable

+1
\ No newline at end of file

parsing/air

+1
\ No newline at end of file

parsing/alder

+1
\ No newline at end of file

parsing/all

+1
\ No newline at end of file

parsing/always

+1
\ No newline at end of file

parsing/among

+1
\ No newline at end of file

parsing/an

+0
\ No newline at end of file

parsing/ancient

+1
\ No newline at end of file

parsing/anciently

+2ancient
\ No newline at end of file

parsing/ancients

+2ancient
\ No newline at end of file

parsing/and

+0
\ No newline at end of file

parsing/any

+1
\ No newline at end of file

parsing/apartment

+1
\ No newline at end of file

parsing/apartments

+2apartment
\ No newline at end of file

parsing/appear

+1
\ No newline at end of file

parsing/appreciate

+1
\ No newline at end of file

parsing/arbitrary

+1
\ No newline at end of file

parsing/arch

+1
\ No newline at end of file

parsing/arches

+2arch
\ No newline at end of file

parsing/architect

+1
\ No newline at end of file

parsing/architects

+2architect
\ No newline at end of file

parsing/architecture

+1
\ No newline at end of file

parsing/are

+0
\ No newline at end of file

parsing/areostyle

+1
\ No newline at end of file

parsing/argument

+1
\ No newline at end of file

parsing/arguments

+2argument
\ No newline at end of file

parsing/arithmetic

+1
\ No newline at end of file

parsing/arithmetick

+2arithmetic
\ No newline at end of file

parsing/arrived

+1
\ No newline at end of file

parsing/art

+1
\ No newline at end of file

parsing/article

+1
\ No newline at end of file

parsing/as

+0
\ No newline at end of file

parsing/astronomy

+1
\ No newline at end of file

parsing/at

+0
\ No newline at end of file

parsing/attic

+1
\ No newline at end of file

parsing/away

+1
\ No newline at end of file

parsing/baboo

+1
\ No newline at end of file

parsing/bad

+1
\ No newline at end of file

parsing/badge

+1
\ No newline at end of file

parsing/base

+1
\ No newline at end of file

parsing/bazar

+1
\ No newline at end of file

parsing/be

+0
\ No newline at end of file

parsing/beauty

+1
\ No newline at end of file

parsing/been

+0
\ No newline at end of file

parsing/beg

+1
\ No newline at end of file

parsing/betel

+1
\ No newline at end of file

parsing/between

+1
\ No newline at end of file

parsing/binding

+2bound
\ No newline at end of file

parsing/book

+1
\ No newline at end of file

parsing/books

+2book
\ No newline at end of file

parsing/borne

+1
\ No newline at end of file

parsing/borrowed

+1
\ No newline at end of file

parsing/bound

+1
\ No newline at end of file

parsing/boundless

+1
\ No newline at end of file

parsing/breath

+1
\ No newline at end of file

parsing/brick

+1
\ No newline at end of file

parsing/bricks

+2brick
\ No newline at end of file

parsing/brings

+1
\ No newline at end of file

parsing/brown

+1
\ No newline at end of file

parsing/building

+1
\ No newline at end of file

parsing/buildings

+2building
\ No newline at end of file

parsing/bundal

+0
\ No newline at end of file

parsing/bundle

+1
\ No newline at end of file

parsing/burra

+0
\ No newline at end of file

parsing/business

+1
\ No newline at end of file

parsing/but

+1
\ No newline at end of file

parsing/butress

+1
\ No newline at end of file

parsing/butresses

+2butress
\ No newline at end of file

parsing/by

+1
\ No newline at end of file

parsing/came

+1
\ No newline at end of file

parsing/capital

+1
\ No newline at end of file

parsing/captial

+1
\ No newline at end of file

parsing/care

+2cared
\ No newline at end of file

parsing/cared

+1
\ No newline at end of file

parsing/caw

+1
\ No newline at end of file

parsing/caws

+2caw
\ No newline at end of file

parsing/cedar

+1
\ No newline at end of file

parsing/ceiling

+1
\ No newline at end of file

parsing/chambrant

+1
\ No newline at end of file

parsing/chambrantes

+2chambrant
\ No newline at end of file

parsing/channeling

+1
\ No newline at end of file

parsing/channelings

+2channeling
\ No newline at end of file

parsing/chap

+1
\ No newline at end of file

parsing/cheek

+1
\ No newline at end of file

parsing/choice

+1
\ No newline at end of file