strlen 32768 
Out of 1000 strings, exactly 506 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  14750.093 cycles per operation (best)  2.222 bytes per cycle (best) 	14883.324 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  33646.535 cycles per operation (best)  0.974 bytes per cycle (best) 	33743.996 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  8083.113 cycles per operation (best)  4.054 bytes per cycle (best) 	8094.905 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  8214.326 cycles per operation (best)  3.989 bytes per cycle (best) 	8268.199 cycles per operation (avg) 

strlen 10 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.217 cycles per operation (best)  0.431 bytes per cycle (best) 	24.115 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  20.456 cycles per operation (best)  0.489 bytes per cycle (best) 	21.962 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  17.578 cycles per operation (best)  0.569 bytes per cycle (best) 	19.106 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  29.135 cycles per operation (best)  0.343 bytes per cycle (best) 	30.200 cycles per operation (avg) 

strlen 11 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.628 cycles per operation (best)  0.466 bytes per cycle (best) 	24.616 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  25.010 cycles per operation (best)  0.440 bytes per cycle (best) 	25.383 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  19.400 cycles per operation (best)  0.567 bytes per cycle (best) 	21.171 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  31.308 cycles per operation (best)  0.351 bytes per cycle (best) 	31.864 cycles per operation (avg) 

strlen 12 
Out of 1000 strings, exactly 491 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.824 cycles per operation (best)  0.526 bytes per cycle (best) 	23.823 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  22.908 cycles per operation (best)  0.524 bytes per cycle (best) 	24.201 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  22.677 cycles per operation (best)  0.529 bytes per cycle (best) 	23.772 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  32.184 cycles per operation (best)  0.373 bytes per cycle (best) 	32.592 cycles per operation (avg) 

strlen 13 
Out of 1000 strings, exactly 495 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  19.081 cycles per operation (best)  0.681 bytes per cycle (best) 	20.871 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  25.985 cycles per operation (best)  0.500 bytes per cycle (best) 	26.688 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.842 cycles per operation (best)  0.595 bytes per cycle (best) 	22.846 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.123 cycles per operation (best)  0.392 bytes per cycle (best) 	33.561 cycles per operation (avg) 

strlen 14 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.717 cycles per operation (best)  0.616 bytes per cycle (best) 	24.379 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  25.869 cycles per operation (best)  0.541 bytes per cycle (best) 	27.551 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  25.248 cycles per operation (best)  0.554 bytes per cycle (best) 	25.647 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  35.586 cycles per operation (best)  0.393 bytes per cycle (best) 	36.110 cycles per operation (avg) 

strlen 15 
Out of 1000 strings, exactly 509 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.799 cycles per operation (best)  0.658 bytes per cycle (best) 	24.297 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  29.617 cycles per operation (best)  0.506 bytes per cycle (best) 	30.607 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  25.760 cycles per operation (best)  0.582 bytes per cycle (best) 	26.994 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.477 cycles per operation (best)  0.411 bytes per cycle (best) 	36.807 cycles per operation (avg) 

strlen 16 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.779 cycles per operation (best)  0.702 bytes per cycle (best) 	23.984 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  29.629 cycles per operation (best)  0.540 bytes per cycle (best) 	30.754 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  20.847 cycles per operation (best)  0.767 bytes per cycle (best) 	21.091 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  27.458 cycles per operation (best)  0.583 bytes per cycle (best) 	28.639 cycles per operation (avg) 

strlen 17 
Out of 1000 strings, exactly 492 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  20.660 cycles per operation (best)  0.823 bytes per cycle (best) 	22.715 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  31.666 cycles per operation (best)  0.537 bytes per cycle (best) 	32.268 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  22.185 cycles per operation (best)  0.766 bytes per cycle (best) 	22.882 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  29.148 cycles per operation (best)  0.583 bytes per cycle (best) 	30.589 cycles per operation (avg) 

strlen 18 
Out of 1000 strings, exactly 515 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.406 cycles per operation (best)  0.803 bytes per cycle (best) 	23.862 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  32.456 cycles per operation (best)  0.555 bytes per cycle (best) 	33.554 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  22.034 cycles per operation (best)  0.817 bytes per cycle (best) 	23.347 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  31.098 cycles per operation (best)  0.579 bytes per cycle (best) 	32.387 cycles per operation (avg) 

strlen 19 
Out of 1000 strings, exactly 500 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.666 cycles per operation (best)  0.803 bytes per cycle (best) 	24.896 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  34.576 cycles per operation (best)  0.550 bytes per cycle (best) 	35.049 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  25.847 cycles per operation (best)  0.735 bytes per cycle (best) 	26.170 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  32.753 cycles per operation (best)  0.580 bytes per cycle (best) 	33.732 cycles per operation (avg) 

strlen 20 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.791 cycles per operation (best)  0.841 bytes per cycle (best) 	25.831 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  35.134 cycles per operation (best)  0.569 bytes per cycle (best) 	35.877 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.714 cycles per operation (best)  0.749 bytes per cycle (best) 	27.865 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.371 cycles per operation (best)  0.582 bytes per cycle (best) 	35.414 cycles per operation (avg) 

strlen 21 
Out of 1000 strings, exactly 490 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.718 cycles per operation (best)  0.885 bytes per cycle (best) 	25.954 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  35.915 cycles per operation (best)  0.585 bytes per cycle (best) 	36.359 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.410 cycles per operation (best)  0.739 bytes per cycle (best) 	29.012 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.498 cycles per operation (best)  0.609 bytes per cycle (best) 	35.456 cycles per operation (avg) 

strlen 22 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  25.909 cycles per operation (best)  0.849 bytes per cycle (best) 	27.023 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  37.588 cycles per operation (best)  0.585 bytes per cycle (best) 	38.147 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.851 cycles per operation (best)  0.763 bytes per cycle (best) 	30.016 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  35.297 cycles per operation (best)  0.623 bytes per cycle (best) 	37.656 cycles per operation (avg) 

strlen 23 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.630 cycles per operation (best)  0.973 bytes per cycle (best) 	25.610 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  38.836 cycles per operation (best)  0.592 bytes per cycle (best) 	39.395 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  31.036 cycles per operation (best)  0.741 bytes per cycle (best) 	31.135 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.385 cycles per operation (best)  0.615 bytes per cycle (best) 	38.096 cycles per operation (avg) 

strlen 24 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.825 cycles per operation (best)  1.007 bytes per cycle (best) 	27.608 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  40.080 cycles per operation (best)  0.599 bytes per cycle (best) 	40.685 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  22.733 cycles per operation (best)  1.056 bytes per cycle (best) 	23.857 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  32.481 cycles per operation (best)  0.739 bytes per cycle (best) 	33.546 cycles per operation (avg) 

strlen 25 
Out of 1000 strings, exactly 516 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.577 cycles per operation (best)  1.017 bytes per cycle (best) 	26.853 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  42.583 cycles per operation (best)  0.587 bytes per cycle (best) 	43.011 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.074 cycles per operation (best)  1.038 bytes per cycle (best) 	25.277 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.949 cycles per operation (best)  0.736 bytes per cycle (best) 	35.214 cycles per operation (avg) 

strlen 26 
Out of 1000 strings, exactly 506 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  26.721 cycles per operation (best)  0.973 bytes per cycle (best) 	27.965 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  42.812 cycles per operation (best)  0.607 bytes per cycle (best) 	43.284 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.071 cycles per operation (best)  1.080 bytes per cycle (best) 	25.172 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.661 cycles per operation (best)  0.750 bytes per cycle (best) 	35.654 cycles per operation (avg) 

strlen 27 
Out of 1000 strings, exactly 492 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.453 cycles per operation (best)  1.151 bytes per cycle (best) 	25.412 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  43.199 cycles per operation (best)  0.625 bytes per cycle (best) 	43.780 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.636 cycles per operation (best)  1.096 bytes per cycle (best) 	25.396 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  35.501 cycles per operation (best)  0.761 bytes per cycle (best) 	36.263 cycles per operation (avg) 

strlen 28 
Out of 1000 strings, exactly 496 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.468 cycles per operation (best)  1.144 bytes per cycle (best) 	25.937 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  44.684 cycles per operation (best)  0.627 bytes per cycle (best) 	44.889 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  25.724 cycles per operation (best)  1.088 bytes per cycle (best) 	26.864 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.743 cycles per operation (best)  0.762 bytes per cycle (best) 	37.289 cycles per operation (avg) 

strlen 29 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.690 cycles per operation (best)  1.224 bytes per cycle (best) 	26.353 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  46.181 cycles per operation (best)  0.628 bytes per cycle (best) 	46.504 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.893 cycles per operation (best)  0.970 bytes per cycle (best) 	30.461 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.530 cycles per operation (best)  0.734 bytes per cycle (best) 	39.921 cycles per operation (avg) 

strlen 30 
Out of 1000 strings, exactly 508 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.827 cycles per operation (best)  1.314 bytes per cycle (best) 	25.264 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  48.576 cycles per operation (best)  0.618 bytes per cycle (best) 	48.648 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  30.848 cycles per operation (best)  0.973 bytes per cycle (best) 	31.499 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.093 cycles per operation (best)  0.730 bytes per cycle (best) 	41.456 cycles per operation (avg) 

strlen 31 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.315 cycles per operation (best)  1.275 bytes per cycle (best) 	26.791 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  48.527 cycles per operation (best)  0.639 bytes per cycle (best) 	49.068 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  31.100 cycles per operation (best)  0.997 bytes per cycle (best) 	32.032 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.894 cycles per operation (best)  0.758 bytes per cycle (best) 	41.299 cycles per operation (avg) 

strlen 32 
Out of 1000 strings, exactly 495 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.249 cycles per operation (best)  1.376 bytes per cycle (best) 	27.567 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  50.796 cycles per operation (best)  0.630 bytes per cycle (best) 	51.376 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  16.787 cycles per operation (best)  1.906 bytes per cycle (best) 	18.946 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  29.492 cycles per operation (best)  1.085 bytes per cycle (best) 	30.680 cycles per operation (avg) 

strlen 33 
Out of 1000 strings, exactly 502 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.546 cycles per operation (best)  1.402 bytes per cycle (best) 	25.543 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  51.707 cycles per operation (best)  0.638 bytes per cycle (best) 	52.156 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  16.105 cycles per operation (best)  2.049 bytes per cycle (best) 	19.031 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  30.679 cycles per operation (best)  1.076 bytes per cycle (best) 	31.659 cycles per operation (avg) 

strlen 34 
Out of 1000 strings, exactly 506 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.273 cycles per operation (best)  1.401 bytes per cycle (best) 	27.102 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  55.161 cycles per operation (best)  0.616 bytes per cycle (best) 	55.986 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  19.374 cycles per operation (best)  1.755 bytes per cycle (best) 	22.566 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.796 cycles per operation (best)  1.006 bytes per cycle (best) 	34.377 cycles per operation (avg) 

strlen 35 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.938 cycles per operation (best)  1.462 bytes per cycle (best) 	25.896 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  55.150 cycles per operation (best)  0.635 bytes per cycle (best) 	55.487 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  20.631 cycles per operation (best)  1.696 bytes per cycle (best) 	23.626 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.686 cycles per operation (best)  1.009 bytes per cycle (best) 	35.410 cycles per operation (avg) 

strlen 36 
Out of 1000 strings, exactly 508 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  25.085 cycles per operation (best)  1.435 bytes per cycle (best) 	27.156 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  56.570 cycles per operation (best)  0.636 bytes per cycle (best) 	56.877 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.885 cycles per operation (best)  1.447 bytes per cycle (best) 	29.073 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.837 cycles per operation (best)  0.977 bytes per cycle (best) 	37.345 cycles per operation (avg) 

strlen 37 
Out of 1000 strings, exactly 522 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.002 cycles per operation (best)  1.542 bytes per cycle (best) 	26.339 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  59.988 cycles per operation (best)  0.617 bytes per cycle (best) 	60.409 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.546 cycles per operation (best)  1.394 bytes per cycle (best) 	28.493 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.853 cycles per operation (best)  1.004 bytes per cycle (best) 	37.887 cycles per operation (avg) 

strlen 38 
Out of 1000 strings, exactly 509 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  25.400 cycles per operation (best)  1.496 bytes per cycle (best) 	27.241 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  60.932 cycles per operation (best)  0.624 bytes per cycle (best) 	61.371 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.719 cycles per operation (best)  1.422 bytes per cycle (best) 	29.438 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  38.623 cycles per operation (best)  0.984 bytes per cycle (best) 	39.520 cycles per operation (avg) 

strlen 39 
Out of 1000 strings, exactly 495 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.747 cycles per operation (best)  1.642 bytes per cycle (best) 	26.141 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  66.148 cycles per operation (best)  0.590 bytes per cycle (best) 	66.460 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.764 cycles per operation (best)  1.457 bytes per cycle (best) 	29.213 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.632 cycles per operation (best)  0.984 bytes per cycle (best) 	39.755 cycles per operation (avg) 

strlen 40 
Out of 1000 strings, exactly 509 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.118 cycles per operation (best)  1.659 bytes per cycle (best) 	25.789 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  61.559 cycles per operation (best)  0.650 bytes per cycle (best) 	61.914 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  19.513 cycles per operation (best)  2.050 bytes per cycle (best) 	22.020 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.985 cycles per operation (best)  1.177 bytes per cycle (best) 	34.827 cycles per operation (avg) 

strlen 41 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  25.054 cycles per operation (best)  1.636 bytes per cycle (best) 	27.378 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  64.471 cycles per operation (best)  0.636 bytes per cycle (best) 	64.750 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  19.293 cycles per operation (best)  2.125 bytes per cycle (best) 	22.303 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.050 cycles per operation (best)  1.204 bytes per cycle (best) 	35.232 cycles per operation (avg) 

strlen 42 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.813 cycles per operation (best)  1.458 bytes per cycle (best) 	29.935 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  62.351 cycles per operation (best)  0.674 bytes per cycle (best) 	62.698 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  22.224 cycles per operation (best)  1.890 bytes per cycle (best) 	24.506 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.941 cycles per operation (best)  1.202 bytes per cycle (best) 	35.806 cycles per operation (avg) 

strlen 43 
Out of 1000 strings, exactly 506 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.848 cycles per operation (best)  1.731 bytes per cycle (best) 	27.016 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  65.559 cycles per operation (best)  0.656 bytes per cycle (best) 	68.168 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.426 cycles per operation (best)  1.836 bytes per cycle (best) 	26.184 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.684 cycles per operation (best)  1.172 bytes per cycle (best) 	37.505 cycles per operation (avg) 

strlen 44 
Out of 1000 strings, exactly 487 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.994 cycles per operation (best)  1.760 bytes per cycle (best) 	27.242 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  61.946 cycles per operation (best)  0.710 bytes per cycle (best) 	62.328 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  25.116 cycles per operation (best)  1.752 bytes per cycle (best) 	27.497 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.390 cycles per operation (best)  1.177 bytes per cycle (best) 	38.075 cycles per operation (avg) 

strlen 45 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.453 cycles per operation (best)  1.919 bytes per cycle (best) 	26.142 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  65.267 cycles per operation (best)  0.689 bytes per cycle (best) 	65.522 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.110 cycles per operation (best)  1.601 bytes per cycle (best) 	30.436 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.806 cycles per operation (best)  1.130 bytes per cycle (best) 	40.418 cycles per operation (avg) 

strlen 46 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  21.050 cycles per operation (best)  2.185 bytes per cycle (best) 	23.055 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  56.961 cycles per operation (best)  0.808 bytes per cycle (best) 	57.233 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.809 cycles per operation (best)  1.716 bytes per cycle (best) 	27.975 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.162 cycles per operation (best)  1.272 bytes per cycle (best) 	36.852 cycles per operation (avg) 

strlen 47 
Out of 1000 strings, exactly 510 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  21.283 cycles per operation (best)  2.208 bytes per cycle (best) 	23.338 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  59.760 cycles per operation (best)  0.786 bytes per cycle (best) 	59.942 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.926 cycles per operation (best)  1.683 bytes per cycle (best) 	29.010 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.022 cycles per operation (best)  1.270 bytes per cycle (best) 	37.746 cycles per operation (avg) 

strlen 48 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.229 cycles per operation (best)  2.066 bytes per cycle (best) 	23.906 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  58.723 cycles per operation (best)  0.817 bytes per cycle (best) 	58.964 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  17.032 cycles per operation (best)  2.818 bytes per cycle (best) 	18.946 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  24.765 cycles per operation (best)  1.938 bytes per cycle (best) 	25.912 cycles per operation (avg) 

strlen 49 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.696 cycles per operation (best)  2.068 bytes per cycle (best) 	24.614 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  59.675 cycles per operation (best)  0.821 bytes per cycle (best) 	59.911 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  16.776 cycles per operation (best)  2.921 bytes per cycle (best) 	19.644 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  25.762 cycles per operation (best)  1.902 bytes per cycle (best) 	27.330 cycles per operation (avg) 

strlen 50 
Out of 1000 strings, exactly 506 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  21.792 cycles per operation (best)  2.294 bytes per cycle (best) 	23.895 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  62.247 cycles per operation (best)  0.803 bytes per cycle (best) 	62.498 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  20.057 cycles per operation (best)  2.493 bytes per cycle (best) 	21.942 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  29.109 cycles per operation (best)  1.718 bytes per cycle (best) 	29.840 cycles per operation (avg) 

strlen 51 
Out of 1000 strings, exactly 477 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.339 cycles per operation (best)  2.095 bytes per cycle (best) 	26.596 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  68.260 cycles per operation (best)  0.747 bytes per cycle (best) 	68.551 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.673 cycles per operation (best)  2.353 bytes per cycle (best) 	24.264 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  31.376 cycles per operation (best)  1.625 bytes per cycle (best) 	32.447 cycles per operation (avg) 

strlen 52 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.988 cycles per operation (best)  2.081 bytes per cycle (best) 	27.513 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  72.487 cycles per operation (best)  0.717 bytes per cycle (best) 	72.710 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.708 cycles per operation (best)  2.105 bytes per cycle (best) 	26.982 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.189 cycles per operation (best)  1.521 bytes per cycle (best) 	35.416 cycles per operation (avg) 

strlen 53 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  21.490 cycles per operation (best)  2.466 bytes per cycle (best) 	23.894 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  64.425 cycles per operation (best)  0.823 bytes per cycle (best) 	64.615 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.711 cycles per operation (best)  2.441 bytes per cycle (best) 	24.164 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  32.124 cycles per operation (best)  1.650 bytes per cycle (best) 	32.577 cycles per operation (avg) 

strlen 54 
Out of 1000 strings, exactly 507 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.437 cycles per operation (best)  2.407 bytes per cycle (best) 	24.314 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  66.212 cycles per operation (best)  0.816 bytes per cycle (best) 	66.361 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.645 cycles per operation (best)  1.885 bytes per cycle (best) 	35.653 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.984 cycles per operation (best)  1.422 bytes per cycle (best) 	38.679 cycles per operation (avg) 

strlen 55 
Out of 1000 strings, exactly 513 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.840 cycles per operation (best)  2.408 bytes per cycle (best) 	24.628 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  68.220 cycles per operation (best)  0.806 bytes per cycle (best) 	68.332 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.241 cycles per operation (best)  2.269 bytes per cycle (best) 	25.586 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.651 cycles per operation (best)  1.587 bytes per cycle (best) 	35.158 cycles per operation (avg) 

strlen 56 
Out of 1000 strings, exactly 488 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  21.803 cycles per operation (best)  2.568 bytes per cycle (best) 	23.995 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  66.255 cycles per operation (best)  0.845 bytes per cycle (best) 	66.528 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  16.059 cycles per operation (best)  3.487 bytes per cycle (best) 	18.655 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  29.323 cycles per operation (best)  1.910 bytes per cycle (best) 	29.941 cycles per operation (avg) 

strlen 57 
Out of 1000 strings, exactly 519 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.610 cycles per operation (best)  2.521 bytes per cycle (best) 	24.781 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  71.167 cycles per operation (best)  0.801 bytes per cycle (best) 	71.513 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  17.490 cycles per operation (best)  3.259 bytes per cycle (best) 	20.967 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  31.453 cycles per operation (best)  1.812 bytes per cycle (best) 	32.156 cycles per operation (avg) 

strlen 58 
Out of 1000 strings, exactly 495 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  25.564 cycles per operation (best)  2.269 bytes per cycle (best) 	26.794 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  68.983 cycles per operation (best)  0.841 bytes per cycle (best) 	69.145 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  18.473 cycles per operation (best)  3.140 bytes per cycle (best) 	21.055 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  30.788 cycles per operation (best)  1.884 bytes per cycle (best) 	31.450 cycles per operation (avg) 

strlen 59 
Out of 1000 strings, exactly 514 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.701 cycles per operation (best)  2.599 bytes per cycle (best) 	24.405 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  76.217 cycles per operation (best)  0.774 bytes per cycle (best) 	76.851 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  20.986 cycles per operation (best)  2.811 bytes per cycle (best) 	22.857 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.065 cycles per operation (best)  1.784 bytes per cycle (best) 	33.623 cycles per operation (avg) 

strlen 60 
Out of 1000 strings, exactly 496 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.808 cycles per operation (best)  2.631 bytes per cycle (best) 	24.506 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  74.063 cycles per operation (best)  0.810 bytes per cycle (best) 	74.621 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.175 cycles per operation (best)  2.834 bytes per cycle (best) 	23.816 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.365 cycles per operation (best)  1.798 bytes per cycle (best) 	34.102 cycles per operation (avg) 

strlen 61 
Out of 1000 strings, exactly 492 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  25.790 cycles per operation (best)  2.365 bytes per cycle (best) 	28.083 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  85.545 cycles per operation (best)  0.713 bytes per cycle (best) 	86.924 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.084 cycles per operation (best)  2.172 bytes per cycle (best) 	30.282 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.052 cycles per operation (best)  1.523 bytes per cycle (best) 	40.597 cycles per operation (avg) 

strlen 62 
Out of 1000 strings, exactly 490 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.324 cycles per operation (best)  2.777 bytes per cycle (best) 	24.961 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  87.601 cycles per operation (best)  0.708 bytes per cycle (best) 	93.560 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.737 cycles per operation (best)  2.235 bytes per cycle (best) 	30.056 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.658 cycles per operation (best)  1.563 bytes per cycle (best) 	40.178 cycles per operation (avg) 

strlen 63 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.957 cycles per operation (best)  2.744 bytes per cycle (best) 	24.995 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  78.208 cycles per operation (best)  0.806 bytes per cycle (best) 	78.662 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.582 cycles per operation (best)  2.284 bytes per cycle (best) 	28.477 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.390 cycles per operation (best)  1.731 bytes per cycle (best) 	37.070 cycles per operation (avg) 

strlen 64 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.330 cycles per operation (best)  2.866 bytes per cycle (best) 	24.428 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  77.876 cycles per operation (best)  0.822 bytes per cycle (best) 	78.199 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  14.388 cycles per operation (best)  4.448 bytes per cycle (best) 	17.247 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  26.639 cycles per operation (best)  2.402 bytes per cycle (best) 	27.629 cycles per operation (avg) 

strlen 65 
Out of 1000 strings, exactly 482 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.957 cycles per operation (best)  2.831 bytes per cycle (best) 	24.735 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  89.551 cycles per operation (best)  0.726 bytes per cycle (best) 	95.430 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  18.496 cycles per operation (best)  3.514 bytes per cycle (best) 	22.172 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  32.717 cycles per operation (best)  1.987 bytes per cycle (best) 	34.231 cycles per operation (avg) 

strlen 66 
Out of 1000 strings, exactly 496 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.426 cycles per operation (best)  2.406 bytes per cycle (best) 	29.608 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  93.253 cycles per operation (best)  0.708 bytes per cycle (best) 	93.936 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  20.627 cycles per operation (best)  3.200 bytes per cycle (best) 	23.689 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.879 cycles per operation (best)  1.790 bytes per cycle (best) 	37.349 cycles per operation (avg) 

strlen 67 
Out of 1000 strings, exactly 511 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.072 cycles per operation (best)  2.475 bytes per cycle (best) 	29.369 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  96.663 cycles per operation (best)  0.693 bytes per cycle (best) 	96.973 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.553 cycles per operation (best)  2.845 bytes per cycle (best) 	26.881 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.760 cycles per operation (best)  1.823 bytes per cycle (best) 	38.331 cycles per operation (avg) 

strlen 68 
Out of 1000 strings, exactly 478 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.062 cycles per operation (best)  2.949 bytes per cycle (best) 	24.640 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  81.088 cycles per operation (best)  0.839 bytes per cycle (best) 	81.518 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.303 cycles per operation (best)  2.918 bytes per cycle (best) 	25.085 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.396 cycles per operation (best)  1.868 bytes per cycle (best) 	42.683 cycles per operation (avg) 

strlen 69 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.376 cycles per operation (best)  2.952 bytes per cycle (best) 	25.423 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  84.580 cycles per operation (best)  0.816 bytes per cycle (best) 	84.968 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  22.886 cycles per operation (best)  3.015 bytes per cycle (best) 	24.941 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.108 cycles per operation (best)  2.084 bytes per cycle (best) 	33.747 cycles per operation (avg) 

strlen 70 
Out of 1000 strings, exactly 485 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.039 cycles per operation (best)  2.912 bytes per cycle (best) 	25.870 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  83.756 cycles per operation (best)  0.836 bytes per cycle (best) 	84.124 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.767 cycles per operation (best)  2.945 bytes per cycle (best) 	25.533 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.507 cycles per operation (best)  2.029 bytes per cycle (best) 	35.349 cycles per operation (avg) 

strlen 71 
Out of 1000 strings, exactly 495 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.745 cycles per operation (best)  2.559 bytes per cycle (best) 	29.727 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  98.366 cycles per operation (best)  0.722 bytes per cycle (best) 	98.913 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  30.754 cycles per operation (best)  2.309 bytes per cycle (best) 	31.720 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.515 cycles per operation (best)  1.710 bytes per cycle (best) 	41.932 cycles per operation (avg) 

strlen 72 
Out of 1000 strings, exactly 522 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.837 cycles per operation (best)  2.899 bytes per cycle (best) 	26.590 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  92.451 cycles per operation (best)  0.779 bytes per cycle (best) 	92.687 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  20.871 cycles per operation (best)  3.450 bytes per cycle (best) 	22.556 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  32.735 cycles per operation (best)  2.199 bytes per cycle (best) 	33.566 cycles per operation (avg) 

strlen 73 
Out of 1000 strings, exactly 500 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.122 cycles per operation (best)  2.692 bytes per cycle (best) 	32.795 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  100.036 cycles per operation (best)  0.730 bytes per cycle (best) 	100.249 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.231 cycles per operation (best)  2.681 bytes per cycle (best) 	27.754 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.484 cycles per operation (best)  1.947 bytes per cycle (best) 	38.222 cycles per operation (avg) 

strlen 74 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.144 cycles per operation (best)  2.629 bytes per cycle (best) 	29.068 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  94.985 cycles per operation (best)  0.779 bytes per cycle (best) 	95.131 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.528 cycles per operation (best)  3.437 bytes per cycle (best) 	23.949 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.911 cycles per operation (best)  2.182 bytes per cycle (best) 	34.820 cycles per operation (avg) 

strlen 75 
Out of 1000 strings, exactly 491 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.769 cycles per operation (best)  3.155 bytes per cycle (best) 	25.857 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  97.900 cycles per operation (best)  0.766 bytes per cycle (best) 	98.064 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  25.294 cycles per operation (best)  2.965 bytes per cycle (best) 	26.045 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  35.632 cycles per operation (best)  2.105 bytes per cycle (best) 	36.125 cycles per operation (avg) 

strlen 76 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.844 cycles per operation (best)  3.187 bytes per cycle (best) 	25.790 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  98.813 cycles per operation (best)  0.769 bytes per cycle (best) 	99.071 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.313 cycles per operation (best)  3.260 bytes per cycle (best) 	24.721 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.710 cycles per operation (best)  2.255 bytes per cycle (best) 	34.627 cycles per operation (avg) 

strlen 77 
Out of 1000 strings, exactly 506 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.245 cycles per operation (best)  3.313 bytes per cycle (best) 	26.093 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  102.636 cycles per operation (best)  0.750 bytes per cycle (best) 	103.243 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.689 cycles per operation (best)  2.781 bytes per cycle (best) 	28.511 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.447 cycles per operation (best)  2.056 bytes per cycle (best) 	37.734 cycles per operation (avg) 

strlen 78 
Out of 1000 strings, exactly 484 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.873 cycles per operation (best)  3.267 bytes per cycle (best) 	25.899 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  97.944 cycles per operation (best)  0.796 bytes per cycle (best) 	98.873 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.206 cycles per operation (best)  2.976 bytes per cycle (best) 	27.751 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.128 cycles per operation (best)  2.159 bytes per cycle (best) 	36.651 cycles per operation (avg) 

strlen 79 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  23.902 cycles per operation (best)  3.305 bytes per cycle (best) 	26.404 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  102.160 cycles per operation (best)  0.773 bytes per cycle (best) 	103.793 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.473 cycles per operation (best)  2.775 bytes per cycle (best) 	29.462 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  38.226 cycles per operation (best)  2.067 bytes per cycle (best) 	38.803 cycles per operation (avg) 

strlen 80 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.345 cycles per operation (best)  2.726 bytes per cycle (best) 	33.117 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  117.665 cycles per operation (best)  0.680 bytes per cycle (best) 	118.559 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  19.744 cycles per operation (best)  4.052 bytes per cycle (best) 	22.487 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.342 cycles per operation (best)  2.330 bytes per cycle (best) 	35.446 cycles per operation (avg) 

strlen 81 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.305 cycles per operation (best)  2.966 bytes per cycle (best) 	32.598 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  115.309 cycles per operation (best)  0.702 bytes per cycle (best) 	115.434 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.356 cycles per operation (best)  3.468 bytes per cycle (best) 	24.936 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  35.536 cycles per operation (best)  2.279 bytes per cycle (best) 	36.579 cycles per operation (avg) 

strlen 82 
Out of 1000 strings, exactly 515 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.829 cycles per operation (best)  3.592 bytes per cycle (best) 	26.516 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  108.287 cycles per operation (best)  0.757 bytes per cycle (best) 	109.015 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  18.767 cycles per operation (best)  4.369 bytes per cycle (best) 	21.375 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  32.099 cycles per operation (best)  2.555 bytes per cycle (best) 	33.334 cycles per operation (avg) 

strlen 83 
Out of 1000 strings, exactly 506 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.275 cycles per operation (best)  2.935 bytes per cycle (best) 	36.076 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  122.699 cycles per operation (best)  0.676 bytes per cycle (best) 	124.134 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.297 cycles per operation (best)  2.933 bytes per cycle (best) 	30.098 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.286 cycles per operation (best)  2.113 bytes per cycle (best) 	40.240 cycles per operation (avg) 

strlen 84 
Out of 1000 strings, exactly 507 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  24.609 cycles per operation (best)  3.413 bytes per cycle (best) 	27.035 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  108.194 cycles per operation (best)  0.776 bytes per cycle (best) 	109.268 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.064 cycles per operation (best)  3.642 bytes per cycle (best) 	25.111 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  32.588 cycles per operation (best)  2.578 bytes per cycle (best) 	33.307 cycles per operation (avg) 

strlen 85 
Out of 1000 strings, exactly 492 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.049 cycles per operation (best)  3.030 bytes per cycle (best) 	32.858 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  121.443 cycles per operation (best)  0.700 bytes per cycle (best) 	122.374 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.969 cycles per operation (best)  3.152 bytes per cycle (best) 	28.824 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.006 cycles per operation (best)  2.179 bytes per cycle (best) 	39.872 cycles per operation (avg) 

strlen 86 
Out of 1000 strings, exactly 485 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  25.812 cycles per operation (best)  3.332 bytes per cycle (best) 	29.770 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  116.134 cycles per operation (best)  0.741 bytes per cycle (best) 	117.926 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.027 cycles per operation (best)  3.068 bytes per cycle (best) 	29.854 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  38.965 cycles per operation (best)  2.207 bytes per cycle (best) 	40.045 cycles per operation (avg) 

strlen 87 
Out of 1000 strings, exactly 515 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.350 cycles per operation (best)  3.069 bytes per cycle (best) 	34.228 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  126.044 cycles per operation (best)  0.690 bytes per cycle (best) 	127.324 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  33.188 cycles per operation (best)  2.621 bytes per cycle (best) 	33.552 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.022 cycles per operation (best)  2.070 bytes per cycle (best) 	42.584 cycles per operation (avg) 

strlen 88 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.583 cycles per operation (best)  2.975 bytes per cycle (best) 	31.271 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  118.664 cycles per operation (best)  0.742 bytes per cycle (best) 	118.773 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  20.698 cycles per operation (best)  4.252 bytes per cycle (best) 	24.328 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  38.500 cycles per operation (best)  2.286 bytes per cycle (best) 	39.429 cycles per operation (avg) 

strlen 89 
Out of 1000 strings, exactly 496 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.418 cycles per operation (best)  3.132 bytes per cycle (best) 	33.237 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  118.014 cycles per operation (best)  0.754 bytes per cycle (best) 	118.416 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.293 cycles per operation (best)  4.180 bytes per cycle (best) 	23.910 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.165 cycles per operation (best)  2.395 bytes per cycle (best) 	38.351 cycles per operation (avg) 

strlen 90 
Out of 1000 strings, exactly 475 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  22.673 cycles per operation (best)  3.969 bytes per cycle (best) 	26.170 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  97.032 cycles per operation (best)  0.928 bytes per cycle (best) 	97.162 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  19.177 cycles per operation (best)  4.693 bytes per cycle (best) 	21.546 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  32.775 cycles per operation (best)  2.746 bytes per cycle (best) 	33.816 cycles per operation (avg) 

strlen 91 
Out of 1000 strings, exactly 487 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.896 cycles per operation (best)  3.262 bytes per cycle (best) 	33.007 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  114.292 cycles per operation (best)  0.796 bytes per cycle (best) 	114.482 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.009 cycles per operation (best)  3.790 bytes per cycle (best) 	26.633 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.001 cycles per operation (best)  2.275 bytes per cycle (best) 	40.693 cycles per operation (avg) 

strlen 92 
Out of 1000 strings, exactly 494 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.581 cycles per operation (best)  3.110 bytes per cycle (best) 	32.328 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  117.127 cycles per operation (best)  0.785 bytes per cycle (best) 	117.200 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.805 cycles per operation (best)  3.709 bytes per cycle (best) 	27.386 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.110 cycles per operation (best)  2.294 bytes per cycle (best) 	40.809 cycles per operation (avg) 

strlen 93 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.003 cycles per operation (best)  3.321 bytes per cycle (best) 	33.233 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  120.626 cycles per operation (best)  0.771 bytes per cycle (best) 	120.920 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.879 cycles per operation (best)  3.220 bytes per cycle (best) 	30.711 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.018 cycles per operation (best)  2.213 bytes per cycle (best) 	42.937 cycles per operation (avg) 

strlen 94 
Out of 1000 strings, exactly 485 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.840 cycles per operation (best)  3.376 bytes per cycle (best) 	31.485 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  116.420 cycles per operation (best)  0.807 bytes per cycle (best) 	116.723 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  31.021 cycles per operation (best)  3.030 bytes per cycle (best) 	31.973 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.337 cycles per operation (best)  2.274 bytes per cycle (best) 	42.083 cycles per operation (avg) 

strlen 95 
Out of 1000 strings, exactly 496 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  26.397 cycles per operation (best)  3.599 bytes per cycle (best) 	31.704 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  134.777 cycles per operation (best)  0.705 bytes per cycle (best) 	138.276 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  31.552 cycles per operation (best)  3.011 bytes per cycle (best) 	32.903 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.005 cycles per operation (best)  2.209 bytes per cycle (best) 	43.770 cycles per operation (avg) 

strlen 96 
Out of 1000 strings, exactly 507 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  26.453 cycles per operation (best)  3.629 bytes per cycle (best) 	27.768 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  135.634 cycles per operation (best)  0.708 bytes per cycle (best) 	141.604 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.475 cycles per operation (best)  4.470 bytes per cycle (best) 	23.951 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.768 cycles per operation (best)  2.843 bytes per cycle (best) 	34.751 cycles per operation (avg) 

strlen 97 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  26.949 cycles per operation (best)  3.599 bytes per cycle (best) 	32.283 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  135.585 cycles per operation (best)  0.715 bytes per cycle (best) 	135.803 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.264 cycles per operation (best)  4.562 bytes per cycle (best) 	25.567 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.328 cycles per operation (best)  2.466 bytes per cycle (best) 	40.561 cycles per operation (avg) 

strlen 98 
Out of 1000 strings, exactly 508 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.602 cycles per operation (best)  3.426 bytes per cycle (best) 	32.922 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  138.354 cycles per operation (best)  0.708 bytes per cycle (best) 	138.506 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  25.122 cycles per operation (best)  3.901 bytes per cycle (best) 	28.075 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.258 cycles per operation (best)  2.496 bytes per cycle (best) 	40.703 cycles per operation (avg) 

strlen 99 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.076 cycles per operation (best)  3.656 bytes per cycle (best) 	32.172 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  135.172 cycles per operation (best)  0.732 bytes per cycle (best) 	135.242 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.821 cycles per operation (best)  3.435 bytes per cycle (best) 	30.916 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.271 cycles per operation (best)  2.399 bytes per cycle (best) 	42.301 cycles per operation (avg) 

strlen 100 
Out of 1000 strings, exactly 491 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.898 cycles per operation (best)  3.460 bytes per cycle (best) 	31.966 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  135.402 cycles per operation (best)  0.739 bytes per cycle (best) 	135.942 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.447 cycles per operation (best)  3.643 bytes per cycle (best) 	29.942 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.352 cycles per operation (best)  2.541 bytes per cycle (best) 	40.232 cycles per operation (avg) 

strlen 101 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.942 cycles per operation (best)  3.615 bytes per cycle (best) 	32.481 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  138.389 cycles per operation (best)  0.730 bytes per cycle (best) 	138.554 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.099 cycles per operation (best)  3.471 bytes per cycle (best) 	30.841 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.527 cycles per operation (best)  2.492 bytes per cycle (best) 	41.278 cycles per operation (avg) 

strlen 102 
Out of 1000 strings, exactly 502 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.225 cycles per operation (best)  3.614 bytes per cycle (best) 	32.335 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  141.061 cycles per operation (best)  0.723 bytes per cycle (best) 	141.139 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.605 cycles per operation (best)  3.128 bytes per cycle (best) 	33.808 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.121 cycles per operation (best)  2.422 bytes per cycle (best) 	43.179 cycles per operation (avg) 

strlen 103 
Out of 1000 strings, exactly 476 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  26.468 cycles per operation (best)  3.891 bytes per cycle (best) 	31.238 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  135.459 cycles per operation (best)  0.760 bytes per cycle (best) 	135.540 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.912 cycles per operation (best)  3.443 bytes per cycle (best) 	31.330 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.634 cycles per operation (best)  2.535 bytes per cycle (best) 	41.731 cycles per operation (avg) 

strlen 104 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  25.447 cycles per operation (best)  4.087 bytes per cycle (best) 	27.457 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  124.346 cycles per operation (best)  0.836 bytes per cycle (best) 	124.558 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.141 cycles per operation (best)  3.978 bytes per cycle (best) 	26.627 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  34.099 cycles per operation (best)  3.050 bytes per cycle (best) 	35.216 cycles per operation (avg) 

strlen 105 
Out of 1000 strings, exactly 500 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.499 cycles per operation (best)  3.818 bytes per cycle (best) 	33.090 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  143.626 cycles per operation (best)  0.731 bytes per cycle (best) 	143.847 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.458 cycles per operation (best)  4.476 bytes per cycle (best) 	26.913 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.030 cycles per operation (best)  2.623 bytes per cycle (best) 	41.023 cycles per operation (avg) 

strlen 106 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.493 cycles per operation (best)  3.856 bytes per cycle (best) 	31.228 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  143.958 cycles per operation (best)  0.736 bytes per cycle (best) 	144.042 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.449 cycles per operation (best)  3.862 bytes per cycle (best) 	29.794 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.567 cycles per operation (best)  2.490 bytes per cycle (best) 	43.344 cycles per operation (avg) 

strlen 107 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  26.919 cycles per operation (best)  3.975 bytes per cycle (best) 	31.911 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  147.046 cycles per operation (best)  0.728 bytes per cycle (best) 	147.137 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  30.260 cycles per operation (best)  3.536 bytes per cycle (best) 	31.380 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.550 cycles per operation (best)  2.457 bytes per cycle (best) 	44.438 cycles per operation (avg) 

strlen 108 
Out of 1000 strings, exactly 512 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.130 cycles per operation (best)  3.839 bytes per cycle (best) 	32.011 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  151.121 cycles per operation (best)  0.715 bytes per cycle (best) 	151.422 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  31.481 cycles per operation (best)  3.431 bytes per cycle (best) 	32.783 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.104 cycles per operation (best)  2.506 bytes per cycle (best) 	43.932 cycles per operation (avg) 

strlen 109 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  26.558 cycles per operation (best)  4.104 bytes per cycle (best) 	31.755 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  149.154 cycles per operation (best)  0.731 bytes per cycle (best) 	149.339 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  31.944 cycles per operation (best)  3.412 bytes per cycle (best) 	33.789 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.428 cycles per operation (best)  2.453 bytes per cycle (best) 	45.064 cycles per operation (avg) 

strlen 110 
Out of 1000 strings, exactly 496 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.162 cycles per operation (best)  3.772 bytes per cycle (best) 	32.643 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  148.868 cycles per operation (best)  0.739 bytes per cycle (best) 	149.012 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  33.154 cycles per operation (best)  3.318 bytes per cycle (best) 	34.380 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.539 cycles per operation (best)  2.416 bytes per cycle (best) 	46.435 cycles per operation (avg) 

strlen 111 
Out of 1000 strings, exactly 512 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  26.369 cycles per operation (best)  4.209 bytes per cycle (best) 	32.412 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  154.211 cycles per operation (best)  0.720 bytes per cycle (best) 	154.367 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.494 cycles per operation (best)  3.042 bytes per cycle (best) 	37.241 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.413 cycles per operation (best)  2.341 bytes per cycle (best) 	51.238 cycles per operation (avg) 

strlen 112 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  25.295 cycles per operation (best)  4.428 bytes per cycle (best) 	26.836 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  131.916 cycles per operation (best)  0.849 bytes per cycle (best) 	132.089 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  17.772 cycles per operation (best)  6.302 bytes per cycle (best) 	20.704 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  31.166 cycles per operation (best)  3.594 bytes per cycle (best) 	32.247 cycles per operation (avg) 

strlen 113 
Out of 1000 strings, exactly 500 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.170 cycles per operation (best)  4.159 bytes per cycle (best) 	32.719 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  153.500 cycles per operation (best)  0.736 bytes per cycle (best) 	153.735 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.439 cycles per operation (best)  5.271 bytes per cycle (best) 	25.238 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  35.201 cycles per operation (best)  3.210 bytes per cycle (best) 	38.287 cycles per operation (avg) 

strlen 114 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.417 cycles per operation (best)  4.158 bytes per cycle (best) 	37.659 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  153.508 cycles per operation (best)  0.743 bytes per cycle (best) 	153.617 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.096 cycles per operation (best)  4.731 bytes per cycle (best) 	27.767 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  38.578 cycles per operation (best)  2.955 bytes per cycle (best) 	40.020 cycles per operation (avg) 

strlen 115 
Out of 1000 strings, exactly 484 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  25.681 cycles per operation (best)  4.478 bytes per cycle (best) 	31.782 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  149.972 cycles per operation (best)  0.767 bytes per cycle (best) 	150.330 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  25.095 cycles per operation (best)  4.583 bytes per cycle (best) 	28.900 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  38.324 cycles per operation (best)  3.001 bytes per cycle (best) 	40.090 cycles per operation (avg) 

strlen 116 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.654 cycles per operation (best)  4.195 bytes per cycle (best) 	31.562 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  155.742 cycles per operation (best)  0.745 bytes per cycle (best) 	156.012 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.297 cycles per operation (best)  3.959 bytes per cycle (best) 	30.987 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.680 cycles per operation (best)  2.923 bytes per cycle (best) 	41.181 cycles per operation (avg) 

strlen 117 
Out of 1000 strings, exactly 527 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  30.028 cycles per operation (best)  3.896 bytes per cycle (best) 	35.413 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  166.694 cycles per operation (best)  0.702 bytes per cycle (best) 	166.757 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.329 cycles per operation (best)  4.130 bytes per cycle (best) 	31.985 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.388 cycles per operation (best)  2.697 bytes per cycle (best) 	44.452 cycles per operation (avg) 

strlen 118 
Out of 1000 strings, exactly 500 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.831 cycles per operation (best)  4.240 bytes per cycle (best) 	37.349 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  158.531 cycles per operation (best)  0.744 bytes per cycle (best) 	158.618 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.035 cycles per operation (best)  3.683 bytes per cycle (best) 	33.329 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.337 cycles per operation (best)  2.661 bytes per cycle (best) 	45.098 cycles per operation (avg) 

strlen 119 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.866 cycles per operation (best)  4.270 bytes per cycle (best) 	32.879 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  157.197 cycles per operation (best)  0.757 bytes per cycle (best) 	157.276 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.535 cycles per operation (best)  3.658 bytes per cycle (best) 	33.821 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.048 cycles per operation (best)  2.764 bytes per cycle (best) 	44.638 cycles per operation (avg) 

strlen 120 
Out of 1000 strings, exactly 494 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  30.061 cycles per operation (best)  3.992 bytes per cycle (best) 	37.614 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  158.753 cycles per operation (best)  0.756 bytes per cycle (best) 	158.854 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  22.683 cycles per operation (best)  5.290 bytes per cycle (best) 	25.843 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.151 cycles per operation (best)  3.065 bytes per cycle (best) 	39.939 cycles per operation (avg) 

strlen 121 
Out of 1000 strings, exactly 502 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.821 cycles per operation (best)  4.349 bytes per cycle (best) 	33.364 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  162.414 cycles per operation (best)  0.745 bytes per cycle (best) 	162.595 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.560 cycles per operation (best)  5.136 bytes per cycle (best) 	27.308 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.529 cycles per operation (best)  2.986 bytes per cycle (best) 	41.992 cycles per operation (avg) 

strlen 122 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.213 cycles per operation (best)  4.324 bytes per cycle (best) 	32.342 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  163.439 cycles per operation (best)  0.746 bytes per cycle (best) 	163.549 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  25.107 cycles per operation (best)  4.859 bytes per cycle (best) 	28.358 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.540 cycles per operation (best)  2.868 bytes per cycle (best) 	43.224 cycles per operation (avg) 

strlen 123 
Out of 1000 strings, exactly 507 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.648 cycles per operation (best)  4.449 bytes per cycle (best) 	33.615 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  166.623 cycles per operation (best)  0.738 bytes per cycle (best) 	166.887 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.527 cycles per operation (best)  4.468 bytes per cycle (best) 	30.182 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.993 cycles per operation (best)  2.796 bytes per cycle (best) 	44.855 cycles per operation (avg) 

strlen 124 
Out of 1000 strings, exactly 511 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.382 cycles per operation (best)  3.951 bytes per cycle (best) 	34.998 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  169.484 cycles per operation (best)  0.732 bytes per cycle (best) 	169.617 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  30.172 cycles per operation (best)  4.110 bytes per cycle (best) 	31.900 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.710 cycles per operation (best)  2.773 bytes per cycle (best) 	45.530 cycles per operation (avg) 

strlen 125 
Out of 1000 strings, exactly 504 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.154 cycles per operation (best)  4.603 bytes per cycle (best) 	33.242 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  168.261 cycles per operation (best)  0.743 bytes per cycle (best) 	168.411 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.022 cycles per operation (best)  3.674 bytes per cycle (best) 	35.483 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.388 cycles per operation (best)  2.754 bytes per cycle (best) 	46.220 cycles per operation (avg) 

strlen 126 
Out of 1000 strings, exactly 510 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.234 cycles per operation (best)  4.463 bytes per cycle (best) 	33.291 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  171.548 cycles per operation (best)  0.734 bytes per cycle (best) 	171.731 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  33.339 cycles per operation (best)  3.779 bytes per cycle (best) 	35.595 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.570 cycles per operation (best)  2.649 bytes per cycle (best) 	47.964 cycles per operation (avg) 

strlen 127 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.567 cycles per operation (best)  4.446 bytes per cycle (best) 	33.616 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  168.479 cycles per operation (best)  0.754 bytes per cycle (best) 	168.570 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.255 cycles per operation (best)  3.707 bytes per cycle (best) 	35.430 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.879 cycles per operation (best)  2.709 bytes per cycle (best) 	47.613 cycles per operation (avg) 

strlen 128 
Out of 1000 strings, exactly 509 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.146 cycles per operation (best)  4.110 bytes per cycle (best) 	32.341 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  173.797 cycles per operation (best)  0.736 bytes per cycle (best) 	173.891 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  22.979 cycles per operation (best)  5.570 bytes per cycle (best) 	25.402 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.057 cycles per operation (best)  3.550 bytes per cycle (best) 	36.710 cycles per operation (avg) 

strlen 129 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  26.866 cycles per operation (best)  4.802 bytes per cycle (best) 	32.527 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  170.185 cycles per operation (best)  0.758 bytes per cycle (best) 	170.371 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.007 cycles per operation (best)  5.373 bytes per cycle (best) 	26.920 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.345 cycles per operation (best)  3.454 bytes per cycle (best) 	38.767 cycles per operation (avg) 

strlen 130 
Out of 1000 strings, exactly 507 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  26.320 cycles per operation (best)  4.939 bytes per cycle (best) 	29.288 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  153.108 cycles per operation (best)  0.849 bytes per cycle (best) 	153.330 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  22.645 cycles per operation (best)  5.741 bytes per cycle (best) 	24.830 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  35.134 cycles per operation (best)  3.700 bytes per cycle (best) 	36.332 cycles per operation (avg) 

strlen 131 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.980 cycles per operation (best)  4.682 bytes per cycle (best) 	33.040 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  173.863 cycles per operation (best)  0.753 bytes per cycle (best) 	174.009 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.525 cycles per operation (best)  4.592 bytes per cycle (best) 	31.297 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.690 cycles per operation (best)  3.301 bytes per cycle (best) 	41.310 cycles per operation (avg) 

strlen 132 
Out of 1000 strings, exactly 488 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.821 cycles per operation (best)  4.426 bytes per cycle (best) 	33.852 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  170.545 cycles per operation (best)  0.774 bytes per cycle (best) 	170.604 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.881 cycles per operation (best)  4.418 bytes per cycle (best) 	31.728 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.798 cycles per operation (best)  3.158 bytes per cycle (best) 	42.251 cycles per operation (avg) 

strlen 133 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.639 cycles per operation (best)  4.644 bytes per cycle (best) 	33.695 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  174.821 cycles per operation (best)  0.761 bytes per cycle (best) 	175.211 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.253 cycles per operation (best)  4.124 bytes per cycle (best) 	33.356 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.682 cycles per operation (best)  3.191 bytes per cycle (best) 	42.914 cycles per operation (avg) 

strlen 134 
Out of 1000 strings, exactly 500 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.232 cycles per operation (best)  4.746 bytes per cycle (best) 	32.549 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  176.727 cycles per operation (best)  0.758 bytes per cycle (best) 	176.876 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.161 cycles per operation (best)  3.923 bytes per cycle (best) 	38.397 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.830 cycles per operation (best)  2.989 bytes per cycle (best) 	45.796 cycles per operation (avg) 

strlen 135 
Out of 1000 strings, exactly 516 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.395 cycles per operation (best)  4.593 bytes per cycle (best) 	34.860 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  184.322 cycles per operation (best)  0.732 bytes per cycle (best) 	184.426 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.871 cycles per operation (best)  3.871 bytes per cycle (best) 	35.804 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.615 cycles per operation (best)  2.896 bytes per cycle (best) 	47.173 cycles per operation (avg) 

strlen 136 
Out of 1000 strings, exactly 504 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  30.030 cycles per operation (best)  4.529 bytes per cycle (best) 	32.813 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  181.573 cycles per operation (best)  0.749 bytes per cycle (best) 	181.862 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.721 cycles per operation (best)  5.090 bytes per cycle (best) 	28.749 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.508 cycles per operation (best)  3.276 bytes per cycle (best) 	42.272 cycles per operation (avg) 

strlen 137 
Out of 1000 strings, exactly 488 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.028 cycles per operation (best)  4.720 bytes per cycle (best) 	34.477 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  176.046 cycles per operation (best)  0.778 bytes per cycle (best) 	176.214 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  25.817 cycles per operation (best)  5.307 bytes per cycle (best) 	27.670 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.725 cycles per operation (best)  3.364 bytes per cycle (best) 	41.530 cycles per operation (avg) 

strlen 138 
Out of 1000 strings, exactly 483 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.602 cycles per operation (best)  4.825 bytes per cycle (best) 	33.312 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  175.911 cycles per operation (best)  0.784 bytes per cycle (best) 	176.032 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.399 cycles per operation (best)  4.694 bytes per cycle (best) 	30.655 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.099 cycles per operation (best)  3.358 bytes per cycle (best) 	41.840 cycles per operation (avg) 

strlen 139 
Out of 1000 strings, exactly 504 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.559 cycles per operation (best)  4.702 bytes per cycle (best) 	35.710 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  183.890 cycles per operation (best)  0.756 bytes per cycle (best) 	184.050 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.105 cycles per operation (best)  4.330 bytes per cycle (best) 	33.236 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.269 cycles per operation (best)  3.212 bytes per cycle (best) 	43.976 cycles per operation (avg) 

strlen 140 
Out of 1000 strings, exactly 514 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  27.366 cycles per operation (best)  5.116 bytes per cycle (best) 	29.876 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  164.967 cycles per operation (best)  0.849 bytes per cycle (best) 	165.080 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.301 cycles per operation (best)  4.778 bytes per cycle (best) 	30.462 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.643 cycles per operation (best)  3.532 bytes per cycle (best) 	40.259 cycles per operation (avg) 

strlen 141 
Out of 1000 strings, exactly 491 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.499 cycles per operation (best)  4.476 bytes per cycle (best) 	36.088 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  181.732 cycles per operation (best)  0.776 bytes per cycle (best) 	181.829 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  33.901 cycles per operation (best)  4.159 bytes per cycle (best) 	35.539 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.802 cycles per operation (best)  3.078 bytes per cycle (best) 	46.506 cycles per operation (avg) 

strlen 142 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.146 cycles per operation (best)  4.417 bytes per cycle (best) 	40.205 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  186.789 cycles per operation (best)  0.760 bytes per cycle (best) 	186.892 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  35.477 cycles per operation (best)  4.003 bytes per cycle (best) 	36.594 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  48.823 cycles per operation (best)  2.908 bytes per cycle (best) 	49.235 cycles per operation (avg) 

strlen 143 
Out of 1000 strings, exactly 495 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.420 cycles per operation (best)  4.551 bytes per cycle (best) 	36.430 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  185.523 cycles per operation (best)  0.771 bytes per cycle (best) 	185.645 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.495 cycles per operation (best)  3.918 bytes per cycle (best) 	37.346 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.635 cycles per operation (best)  3.066 bytes per cycle (best) 	47.378 cycles per operation (avg) 

strlen 144 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.334 cycles per operation (best)  5.082 bytes per cycle (best) 	29.337 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  164.709 cycles per operation (best)  0.874 bytes per cycle (best) 	164.799 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.103 cycles per operation (best)  6.824 bytes per cycle (best) 	22.835 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  32.414 cycles per operation (best)  4.443 bytes per cycle (best) 	33.271 cycles per operation (avg) 

strlen 145 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.801 cycles per operation (best)  4.421 bytes per cycle (best) 	38.164 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  189.854 cycles per operation (best)  0.764 bytes per cycle (best) 	190.262 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.807 cycles per operation (best)  5.845 bytes per cycle (best) 	31.443 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.049 cycles per operation (best)  3.621 bytes per cycle (best) 	41.195 cycles per operation (avg) 

strlen 146 
Out of 1000 strings, exactly 508 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.549 cycles per operation (best)  4.628 bytes per cycle (best) 	35.593 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  193.438 cycles per operation (best)  0.755 bytes per cycle (best) 	193.794 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.451 cycles per operation (best)  4.957 bytes per cycle (best) 	30.832 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.718 cycles per operation (best)  3.500 bytes per cycle (best) 	42.420 cycles per operation (avg) 

strlen 147 
Out of 1000 strings, exactly 494 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.093 cycles per operation (best)  4.580 bytes per cycle (best) 	38.365 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  190.235 cycles per operation (best)  0.773 bytes per cycle (best) 	190.348 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.747 cycles per operation (best)  5.298 bytes per cycle (best) 	30.144 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.096 cycles per operation (best)  3.666 bytes per cycle (best) 	41.996 cycles per operation (avg) 

strlen 148 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.566 cycles per operation (best)  4.689 bytes per cycle (best) 	34.957 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  192.897 cycles per operation (best)  0.767 bytes per cycle (best) 	193.071 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  31.005 cycles per operation (best)  4.773 bytes per cycle (best) 	32.877 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.190 cycles per operation (best)  3.593 bytes per cycle (best) 	42.368 cycles per operation (avg) 

strlen 149 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.107 cycles per operation (best)  4.501 bytes per cycle (best) 	38.924 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  193.810 cycles per operation (best)  0.769 bytes per cycle (best) 	197.877 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  31.837 cycles per operation (best)  4.680 bytes per cycle (best) 	33.689 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.128 cycles per operation (best)  3.377 bytes per cycle (best) 	45.334 cycles per operation (avg) 

strlen 150 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.587 cycles per operation (best)  5.070 bytes per cycle (best) 	33.628 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  194.706 cycles per operation (best)  0.770 bytes per cycle (best) 	194.821 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  35.812 cycles per operation (best)  4.189 bytes per cycle (best) 	36.254 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.995 cycles per operation (best)  3.334 bytes per cycle (best) 	45.787 cycles per operation (avg) 

strlen 151 
Out of 1000 strings, exactly 496 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.615 cycles per operation (best)  4.492 bytes per cycle (best) 	38.787 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  195.147 cycles per operation (best)  0.774 bytes per cycle (best) 	195.257 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.110 cycles per operation (best)  4.427 bytes per cycle (best) 	35.546 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.675 cycles per operation (best)  3.306 bytes per cycle (best) 	46.833 cycles per operation (avg) 

strlen 152 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.738 cycles per operation (best)  4.505 bytes per cycle (best) 	35.260 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  197.759 cycles per operation (best)  0.769 bytes per cycle (best) 	197.932 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.670 cycles per operation (best)  6.422 bytes per cycle (best) 	26.714 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.134 cycles per operation (best)  3.787 bytes per cycle (best) 	41.285 cycles per operation (avg) 

strlen 153 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.858 cycles per operation (best)  4.803 bytes per cycle (best) 	37.997 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  200.685 cycles per operation (best)  0.762 bytes per cycle (best) 	201.055 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.029 cycles per operation (best)  5.459 bytes per cycle (best) 	30.308 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.493 cycles per operation (best)  3.778 bytes per cycle (best) 	41.910 cycles per operation (avg) 

strlen 154 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.338 cycles per operation (best)  4.914 bytes per cycle (best) 	35.848 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  202.698 cycles per operation (best)  0.760 bytes per cycle (best) 	202.880 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.097 cycles per operation (best)  5.481 bytes per cycle (best) 	30.749 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.780 cycles per operation (best)  3.600 bytes per cycle (best) 	43.426 cycles per operation (avg) 

strlen 155 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.855 cycles per operation (best)  4.718 bytes per cycle (best) 	38.957 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  201.721 cycles per operation (best)  0.768 bytes per cycle (best) 	201.818 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.420 cycles per operation (best)  5.454 bytes per cycle (best) 	31.131 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.429 cycles per operation (best)  3.569 bytes per cycle (best) 	44.394 cycles per operation (avg) 

strlen 156 
Out of 1000 strings, exactly 510 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  34.061 cycles per operation (best)  4.580 bytes per cycle (best) 	36.953 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  206.189 cycles per operation (best)  0.757 bytes per cycle (best) 	206.326 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.805 cycles per operation (best)  4.755 bytes per cycle (best) 	34.087 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.004 cycles per operation (best)  3.466 bytes per cycle (best) 	45.990 cycles per operation (avg) 

strlen 157 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.539 cycles per operation (best)  4.825 bytes per cycle (best) 	38.816 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  207.810 cycles per operation (best)  0.755 bytes per cycle (best) 	208.070 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  33.645 cycles per operation (best)  4.666 bytes per cycle (best) 	35.594 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.582 cycles per operation (best)  3.300 bytes per cycle (best) 	48.312 cycles per operation (avg) 

strlen 158 
Out of 1000 strings, exactly 509 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.183 cycles per operation (best)  4.909 bytes per cycle (best) 	36.192 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  207.995 cycles per operation (best)  0.760 bytes per cycle (best) 	208.379 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.222 cycles per operation (best)  4.362 bytes per cycle (best) 	37.023 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.038 cycles per operation (best)  3.359 bytes per cycle (best) 	47.940 cycles per operation (avg) 

strlen 159 
Out of 1000 strings, exactly 506 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.188 cycles per operation (best)  4.940 bytes per cycle (best) 	37.587 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  208.299 cycles per operation (best)  0.763 bytes per cycle (best) 	208.624 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.178 cycles per operation (best)  4.395 bytes per cycle (best) 	37.790 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  48.678 cycles per operation (best)  3.266 bytes per cycle (best) 	49.295 cycles per operation (avg) 

strlen 160 
Out of 1000 strings, exactly 513 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.804 cycles per operation (best)  5.368 bytes per cycle (best) 	31.207 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  186.187 cycles per operation (best)  0.859 bytes per cycle (best) 	186.395 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.155 cycles per operation (best)  6.624 bytes per cycle (best) 	32.301 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  36.486 cycles per operation (best)  4.385 bytes per cycle (best) 	37.508 cycles per operation (avg) 

strlen 161 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.045 cycles per operation (best)  5.024 bytes per cycle (best) 	37.659 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  209.783 cycles per operation (best)  0.767 bytes per cycle (best) 	209.922 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.434 cycles per operation (best)  5.662 bytes per cycle (best) 	30.830 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.637 cycles per operation (best)  3.867 bytes per cycle (best) 	42.907 cycles per operation (avg) 

strlen 162 
Out of 1000 strings, exactly 492 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.113 cycles per operation (best)  4.892 bytes per cycle (best) 	36.900 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  206.753 cycles per operation (best)  0.784 bytes per cycle (best) 	206.855 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.938 cycles per operation (best)  5.598 bytes per cycle (best) 	31.130 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.044 cycles per operation (best)  3.853 bytes per cycle (best) 	42.626 cycles per operation (avg) 

strlen 163 
Out of 1000 strings, exactly 495 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  30.736 cycles per operation (best)  5.303 bytes per cycle (best) 	35.620 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  208.150 cycles per operation (best)  0.783 bytes per cycle (best) 	212.798 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  30.845 cycles per operation (best)  5.284 bytes per cycle (best) 	32.618 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.431 cycles per operation (best)  3.842 bytes per cycle (best) 	43.413 cycles per operation (avg) 

strlen 164 
Out of 1000 strings, exactly 489 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.355 cycles per operation (best)  5.069 bytes per cycle (best) 	36.813 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  207.724 cycles per operation (best)  0.790 bytes per cycle (best) 	207.797 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.770 cycles per operation (best)  5.005 bytes per cycle (best) 	34.884 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.125 cycles per operation (best)  3.893 bytes per cycle (best) 	43.352 cycles per operation (avg) 

strlen 165 
Out of 1000 strings, exactly 516 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.099 cycles per operation (best)  4.985 bytes per cycle (best) 	39.168 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  220.698 cycles per operation (best)  0.748 bytes per cycle (best) 	224.571 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.533 cycles per operation (best)  4.516 bytes per cycle (best) 	37.776 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.465 cycles per operation (best)  3.476 bytes per cycle (best) 	47.836 cycles per operation (avg) 

strlen 166 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.464 cycles per operation (best)  5.113 bytes per cycle (best) 	36.340 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  215.573 cycles per operation (best)  0.770 bytes per cycle (best) 	215.769 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  37.002 cycles per operation (best)  4.486 bytes per cycle (best) 	38.189 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.722 cycles per operation (best)  3.631 bytes per cycle (best) 	46.103 cycles per operation (avg) 

strlen 167 
Out of 1000 strings, exactly 507 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.015 cycles per operation (best)  5.058 bytes per cycle (best) 	38.676 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  219.027 cycles per operation (best)  0.762 bytes per cycle (best) 	219.294 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  38.689 cycles per operation (best)  4.316 bytes per cycle (best) 	39.031 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.185 cycles per operation (best)  3.539 bytes per cycle (best) 	48.246 cycles per operation (avg) 

strlen 168 
Out of 1000 strings, exactly 494 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.089 cycles per operation (best)  5.077 bytes per cycle (best) 	36.115 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  214.049 cycles per operation (best)  0.785 bytes per cycle (best) 	214.198 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.928 cycles per operation (best)  6.015 bytes per cycle (best) 	30.271 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.908 cycles per operation (best)  4.210 bytes per cycle (best) 	41.360 cycles per operation (avg) 

strlen 169 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.301 cycles per operation (best)  5.232 bytes per cycle (best) 	37.744 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  214.285 cycles per operation (best)  0.789 bytes per cycle (best) 	214.466 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.262 cycles per operation (best)  5.980 bytes per cycle (best) 	30.699 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.066 cycles per operation (best)  4.017 bytes per cycle (best) 	42.801 cycles per operation (avg) 

strlen 170 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.808 cycles per operation (best)  5.345 bytes per cycle (best) 	36.212 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  218.707 cycles per operation (best)  0.777 bytes per cycle (best) 	218.795 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.615 cycles per operation (best)  5.212 bytes per cycle (best) 	34.115 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.955 cycles per operation (best)  3.958 bytes per cycle (best) 	44.819 cycles per operation (avg) 

strlen 171 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  30.861 cycles per operation (best)  5.541 bytes per cycle (best) 	37.198 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  217.439 cycles per operation (best)  0.786 bytes per cycle (best) 	217.543 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.118 cycles per operation (best)  5.324 bytes per cycle (best) 	34.115 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.172 cycles per operation (best)  3.786 bytes per cycle (best) 	46.064 cycles per operation (avg) 

strlen 172 
Out of 1000 strings, exactly 502 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.708 cycles per operation (best)  5.259 bytes per cycle (best) 	36.324 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  222.527 cycles per operation (best)  0.773 bytes per cycle (best) 	222.812 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.567 cycles per operation (best)  4.976 bytes per cycle (best) 	35.981 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.762 cycles per operation (best)  3.678 bytes per cycle (best) 	47.463 cycles per operation (avg) 

strlen 173 
Out of 1000 strings, exactly 488 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.346 cycles per operation (best)  5.519 bytes per cycle (best) 	36.915 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  217.405 cycles per operation (best)  0.796 bytes per cycle (best) 	217.642 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  37.280 cycles per operation (best)  4.641 bytes per cycle (best) 	38.084 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.508 cycles per operation (best)  3.720 bytes per cycle (best) 	47.465 cycles per operation (avg) 

strlen 174 
Out of 1000 strings, exactly 526 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.867 cycles per operation (best)  5.294 bytes per cycle (best) 	37.144 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  234.762 cycles per operation (best)  0.741 bytes per cycle (best) 	235.067 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  39.304 cycles per operation (best)  4.427 bytes per cycle (best) 	40.267 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  49.783 cycles per operation (best)  3.495 bytes per cycle (best) 	50.257 cycles per operation (avg) 

strlen 175 
Out of 1000 strings, exactly 491 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.743 cycles per operation (best)  5.513 bytes per cycle (best) 	36.759 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  221.397 cycles per operation (best)  0.790 bytes per cycle (best) 	221.604 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  38.357 cycles per operation (best)  4.562 bytes per cycle (best) 	39.469 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  48.547 cycles per operation (best)  3.605 bytes per cycle (best) 	48.953 cycles per operation (avg) 

strlen 176 
Out of 1000 strings, exactly 483 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.686 cycles per operation (best)  5.225 bytes per cycle (best) 	34.928 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  218.923 cycles per operation (best)  0.804 bytes per cycle (best) 	219.035 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.141 cycles per operation (best)  6.040 bytes per cycle (best) 	29.724 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.470 cycles per operation (best)  4.697 bytes per cycle (best) 	38.834 cycles per operation (avg) 

strlen 177 
Out of 1000 strings, exactly 502 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.162 cycles per operation (best)  5.503 bytes per cycle (best) 	37.524 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  228.581 cycles per operation (best)  0.774 bytes per cycle (best) 	228.732 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.432 cycles per operation (best)  6.452 bytes per cycle (best) 	29.697 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.539 cycles per operation (best)  4.261 bytes per cycle (best) 	42.957 cycles per operation (avg) 

strlen 178 
Out of 1000 strings, exactly 496 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.012 cycles per operation (best)  5.740 bytes per cycle (best) 	35.586 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  227.050 cycles per operation (best)  0.784 bytes per cycle (best) 	227.258 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.920 cycles per operation (best)  6.612 bytes per cycle (best) 	30.801 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.051 cycles per operation (best)  4.336 bytes per cycle (best) 	42.550 cycles per operation (avg) 

strlen 179 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.482 cycles per operation (best)  5.511 bytes per cycle (best) 	38.165 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  228.498 cycles per operation (best)  0.783 bytes per cycle (best) 	228.630 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  30.415 cycles per operation (best)  5.885 bytes per cycle (best) 	32.560 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.758 cycles per operation (best)  4.186 bytes per cycle (best) 	44.108 cycles per operation (avg) 

strlen 180 
Out of 1000 strings, exactly 511 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.105 cycles per operation (best)  5.607 bytes per cycle (best) 	35.712 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  235.384 cycles per operation (best)  0.765 bytes per cycle (best) 	235.781 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  30.619 cycles per operation (best)  5.879 bytes per cycle (best) 	34.160 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.470 cycles per operation (best)  4.048 bytes per cycle (best) 	45.354 cycles per operation (avg) 

strlen 181 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.775 cycles per operation (best)  5.696 bytes per cycle (best) 	38.770 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  233.210 cycles per operation (best)  0.776 bytes per cycle (best) 	233.461 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  35.943 cycles per operation (best)  5.036 bytes per cycle (best) 	36.745 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.479 cycles per operation (best)  3.980 bytes per cycle (best) 	46.830 cycles per operation (avg) 

strlen 182 
Out of 1000 strings, exactly 507 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  31.384 cycles per operation (best)  5.799 bytes per cycle (best) 	35.991 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  236.438 cycles per operation (best)  0.770 bytes per cycle (best) 	236.607 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  35.910 cycles per operation (best)  5.068 bytes per cycle (best) 	37.713 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.500 cycles per operation (best)  4.000 bytes per cycle (best) 	46.550 cycles per operation (avg) 

strlen 183 
Out of 1000 strings, exactly 489 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.722 cycles per operation (best)  5.427 bytes per cycle (best) 	39.318 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  228.575 cycles per operation (best)  0.801 bytes per cycle (best) 	228.747 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.539 cycles per operation (best)  5.008 bytes per cycle (best) 	37.775 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.750 cycles per operation (best)  3.914 bytes per cycle (best) 	47.559 cycles per operation (avg) 

strlen 184 
Out of 1000 strings, exactly 483 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  30.050 cycles per operation (best)  6.123 bytes per cycle (best) 	31.641 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  198.954 cycles per operation (best)  0.925 bytes per cycle (best) 	199.158 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  23.058 cycles per operation (best)  7.980 bytes per cycle (best) 	25.322 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.621 cycles per operation (best)  4.891 bytes per cycle (best) 	38.109 cycles per operation (avg) 

strlen 185 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.755 cycles per operation (best)  5.481 bytes per cycle (best) 	39.671 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  236.124 cycles per operation (best)  0.783 bytes per cycle (best) 	236.405 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.723 cycles per operation (best)  6.673 bytes per cycle (best) 	30.818 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.050 cycles per operation (best)  4.200 bytes per cycle (best) 	44.700 cycles per operation (avg) 

strlen 186 
Out of 1000 strings, exactly 519 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  28.341 cycles per operation (best)  6.563 bytes per cycle (best) 	32.776 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  215.789 cycles per operation (best)  0.862 bytes per cycle (best) 	215.906 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.094 cycles per operation (best)  6.621 bytes per cycle (best) 	29.761 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  38.740 cycles per operation (best)  4.801 bytes per cycle (best) 	40.268 cycles per operation (avg) 

strlen 187 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  35.696 cycles per operation (best)  5.239 bytes per cycle (best) 	40.740 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  238.195 cycles per operation (best)  0.785 bytes per cycle (best) 	238.491 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.348 cycles per operation (best)  5.444 bytes per cycle (best) 	35.509 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.742 cycles per operation (best)  4.088 bytes per cycle (best) 	46.416 cycles per operation (avg) 

strlen 188 
Out of 1000 strings, exactly 487 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  34.586 cycles per operation (best)  5.436 bytes per cycle (best) 	37.486 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  234.485 cycles per operation (best)  0.802 bytes per cycle (best) 	234.717 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.265 cycles per operation (best)  5.827 bytes per cycle (best) 	34.326 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.499 cycles per operation (best)  4.132 bytes per cycle (best) 	46.343 cycles per operation (avg) 

strlen 189 
Out of 1000 strings, exactly 471 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.403 cycles per operation (best)  5.658 bytes per cycle (best) 	38.066 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  226.927 cycles per operation (best)  0.833 bytes per cycle (best) 	230.706 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.076 cycles per operation (best)  5.546 bytes per cycle (best) 	34.699 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.011 cycles per operation (best)  4.294 bytes per cycle (best) 	44.987 cycles per operation (avg) 

strlen 190 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  35.134 cycles per operation (best)  5.408 bytes per cycle (best) 	38.815 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  241.724 cycles per operation (best)  0.786 bytes per cycle (best) 	241.957 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  37.668 cycles per operation (best)  5.044 bytes per cycle (best) 	38.347 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  48.597 cycles per operation (best)  3.910 bytes per cycle (best) 	53.227 cycles per operation (avg) 

strlen 191 
Out of 1000 strings, exactly 515 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.581 cycles per operation (best)  5.688 bytes per cycle (best) 	38.919 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  250.887 cycles per operation (best)  0.761 bytes per cycle (best) 	251.057 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  38.568 cycles per operation (best)  4.952 bytes per cycle (best) 	39.883 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  50.302 cycles per operation (best)  3.797 bytes per cycle (best) 	50.980 cycles per operation (avg) 

strlen 192 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.507 cycles per operation (best)  5.906 bytes per cycle (best) 	33.154 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  214.753 cycles per operation (best)  0.894 bytes per cycle (best) 	214.839 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  21.115 cycles per operation (best)  9.093 bytes per cycle (best) 	23.368 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.191 cycles per operation (best)  5.785 bytes per cycle (best) 	34.017 cycles per operation (avg) 

strlen 193 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.767 cycles per operation (best)  5.890 bytes per cycle (best) 	38.396 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  248.422 cycles per operation (best)  0.777 bytes per cycle (best) 	248.654 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.926 cycles per operation (best)  6.672 bytes per cycle (best) 	31.079 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.517 cycles per operation (best)  4.539 bytes per cycle (best) 	43.463 cycles per operation (avg) 

strlen 194 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.623 cycles per operation (best)  5.770 bytes per cycle (best) 	37.951 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  248.678 cycles per operation (best)  0.780 bytes per cycle (best) 	248.923 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.309 cycles per operation (best)  6.619 bytes per cycle (best) 	32.163 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.682 cycles per operation (best)  4.342 bytes per cycle (best) 	45.412 cycles per operation (avg) 

strlen 195 
Out of 1000 strings, exactly 522 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  36.106 cycles per operation (best)  5.401 bytes per cycle (best) 	41.380 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  259.522 cycles per operation (best)  0.751 bytes per cycle (best) 	259.655 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  35.275 cycles per operation (best)  5.528 bytes per cycle (best) 	36.047 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.015 cycles per operation (best)  4.332 bytes per cycle (best) 	45.936 cycles per operation (avg) 

strlen 196 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  36.638 cycles per operation (best)  5.350 bytes per cycle (best) 	39.945 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  250.045 cycles per operation (best)  0.784 bytes per cycle (best) 	250.236 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.464 cycles per operation (best)  5.687 bytes per cycle (best) 	35.542 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.013 cycles per operation (best)  4.453 bytes per cycle (best) 	44.981 cycles per operation (avg) 

strlen 197 
Out of 1000 strings, exactly 495 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  34.998 cycles per operation (best)  5.629 bytes per cycle (best) 	40.882 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  248.367 cycles per operation (best)  0.793 bytes per cycle (best) 	248.798 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.875 cycles per operation (best)  5.342 bytes per cycle (best) 	37.681 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.546 cycles per operation (best)  4.232 bytes per cycle (best) 	47.427 cycles per operation (avg) 

strlen 198 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  29.879 cycles per operation (best)  6.627 bytes per cycle (best) 	34.043 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  222.224 cycles per operation (best)  0.891 bytes per cycle (best) 	222.424 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  39.016 cycles per operation (best)  5.075 bytes per cycle (best) 	44.636 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.777 cycles per operation (best)  4.144 bytes per cycle (best) 	48.638 cycles per operation (avg) 

strlen 199 
Out of 1000 strings, exactly 494 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.033 cycles per operation (best)  6.212 bytes per cycle (best) 	36.535 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  250.015 cycles per operation (best)  0.796 bytes per cycle (best) 	255.579 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  38.685 cycles per operation (best)  5.144 bytes per cycle (best) 	39.350 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.344 cycles per operation (best)  4.203 bytes per cycle (best) 	47.921 cycles per operation (avg) 

strlen 200 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.766 cycles per operation (best)  6.104 bytes per cycle (best) 	34.359 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  224.261 cycles per operation (best)  0.892 bytes per cycle (best) 	224.459 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.886 cycles per operation (best)  7.172 bytes per cycle (best) 	28.583 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.989 cycles per operation (best)  5.265 bytes per cycle (best) 	38.683 cycles per operation (avg) 

strlen 201 
Out of 1000 strings, exactly 486 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  36.610 cycles per operation (best)  5.490 bytes per cycle (best) 	41.595 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  247.453 cycles per operation (best)  0.812 bytes per cycle (best) 	247.800 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  31.162 cycles per operation (best)  6.450 bytes per cycle (best) 	32.765 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.879 cycles per operation (best)  4.581 bytes per cycle (best) 	44.711 cycles per operation (avg) 

strlen 202 
Out of 1000 strings, exactly 508 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  34.770 cycles per operation (best)  5.810 bytes per cycle (best) 	45.570 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  260.292 cycles per operation (best)  0.776 bytes per cycle (best) 	260.456 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  33.861 cycles per operation (best)  5.966 bytes per cycle (best) 	35.032 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.870 cycles per operation (best)  4.220 bytes per cycle (best) 	48.585 cycles per operation (avg) 

strlen 203 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  35.547 cycles per operation (best)  5.711 bytes per cycle (best) 	41.322 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  256.068 cycles per operation (best)  0.793 bytes per cycle (best) 	256.322 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.737 cycles per operation (best)  5.526 bytes per cycle (best) 	37.719 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.501 cycles per operation (best)  4.274 bytes per cycle (best) 	48.236 cycles per operation (avg) 

strlen 204 
Out of 1000 strings, exactly 489 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  36.835 cycles per operation (best)  5.538 bytes per cycle (best) 	40.091 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  252.541 cycles per operation (best)  0.808 bytes per cycle (best) 	252.762 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  35.519 cycles per operation (best)  5.743 bytes per cycle (best) 	36.368 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.508 cycles per operation (best)  4.386 bytes per cycle (best) 	47.095 cycles per operation (avg) 

strlen 205 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.525 cycles per operation (best)  5.187 bytes per cycle (best) 	44.523 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  260.992 cycles per operation (best)  0.785 bytes per cycle (best) 	261.224 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.297 cycles per operation (best)  5.648 bytes per cycle (best) 	37.708 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  49.599 cycles per operation (best)  4.133 bytes per cycle (best) 	50.894 cycles per operation (avg) 

strlen 206 
Out of 1000 strings, exactly 515 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  37.961 cycles per operation (best)  5.427 bytes per cycle (best) 	41.873 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  268.509 cycles per operation (best)  0.767 bytes per cycle (best) 	268.736 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  40.169 cycles per operation (best)  5.128 bytes per cycle (best) 	40.845 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  51.116 cycles per operation (best)  4.030 bytes per cycle (best) 	51.951 cycles per operation (avg) 

strlen 207 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  37.952 cycles per operation (best)  5.454 bytes per cycle (best) 	42.742 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  261.405 cycles per operation (best)  0.792 bytes per cycle (best) 	261.470 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  40.748 cycles per operation (best)  5.080 bytes per cycle (best) 	41.248 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  50.869 cycles per operation (best)  4.069 bytes per cycle (best) 	51.324 cycles per operation (avg) 

strlen 208 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.321 cycles per operation (best)  6.242 bytes per cycle (best) 	34.185 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  260.561 cycles per operation (best)  0.798 bytes per cycle (best) 	270.598 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.765 cycles per operation (best)  7.771 bytes per cycle (best) 	29.096 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  39.302 cycles per operation (best)  5.292 bytes per cycle (best) 	40.641 cycles per operation (avg) 

strlen 209 
Out of 1000 strings, exactly 502 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.040 cycles per operation (best)  5.353 bytes per cycle (best) 	44.152 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  265.160 cycles per operation (best)  0.788 bytes per cycle (best) 	265.380 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.543 cycles per operation (best)  7.074 bytes per cycle (best) 	31.961 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.610 cycles per operation (best)  4.792 bytes per cycle (best) 	44.671 cycles per operation (avg) 

strlen 210 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.920 cycles per operation (best)  6.379 bytes per cycle (best) 	35.523 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  230.159 cycles per operation (best)  0.912 bytes per cycle (best) 	230.514 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  27.083 cycles per operation (best)  7.754 bytes per cycle (best) 	28.859 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  37.359 cycles per operation (best)  5.621 bytes per cycle (best) 	38.103 cycles per operation (avg) 

strlen 211 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.271 cycles per operation (best)  5.373 bytes per cycle (best) 	44.906 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  265.365 cycles per operation (best)  0.795 bytes per cycle (best) 	265.674 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.997 cycles per operation (best)  6.395 bytes per cycle (best) 	34.668 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.771 cycles per operation (best)  4.713 bytes per cycle (best) 	45.976 cycles per operation (avg) 

strlen 212 
Out of 1000 strings, exactly 514 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  42.526 cycles per operation (best)  4.985 bytes per cycle (best) 	44.049 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  275.192 cycles per operation (best)  0.770 bytes per cycle (best) 	275.370 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.885 cycles per operation (best)  6.077 bytes per cycle (best) 	36.477 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.338 cycles per operation (best)  4.676 bytes per cycle (best) 	46.938 cycles per operation (avg) 

strlen 213 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  37.563 cycles per operation (best)  5.670 bytes per cycle (best) 	43.072 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  266.825 cycles per operation (best)  0.798 bytes per cycle (best) 	266.953 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.844 cycles per operation (best)  5.781 bytes per cycle (best) 	37.986 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.584 cycles per operation (best)  4.476 bytes per cycle (best) 	48.230 cycles per operation (avg) 

strlen 214 
Out of 1000 strings, exactly 510 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  38.687 cycles per operation (best)  5.532 bytes per cycle (best) 	43.469 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  275.338 cycles per operation (best)  0.777 bytes per cycle (best) 	275.566 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  38.467 cycles per operation (best)  5.563 bytes per cycle (best) 	40.179 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  48.531 cycles per operation (best)  4.410 bytes per cycle (best) 	49.906 cycles per operation (avg) 

strlen 215 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.496 cycles per operation (best)  5.444 bytes per cycle (best) 	44.743 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  270.387 cycles per operation (best)  0.795 bytes per cycle (best) 	270.554 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  37.576 cycles per operation (best)  5.722 bytes per cycle (best) 	40.006 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  49.039 cycles per operation (best)  4.384 bytes per cycle (best) 	50.022 cycles per operation (avg) 

strlen 216 
Out of 1000 strings, exactly 490 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  36.452 cycles per operation (best)  5.926 bytes per cycle (best) 	37.530 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  233.330 cycles per operation (best)  0.926 bytes per cycle (best) 	233.618 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  24.493 cycles per operation (best)  8.819 bytes per cycle (best) 	26.188 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.435 cycles per operation (best)  4.973 bytes per cycle (best) 	49.749 cycles per operation (avg) 

strlen 217 
Out of 1000 strings, exactly 485 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  34.123 cycles per operation (best)  6.359 bytes per cycle (best) 	38.918 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  232.027 cycles per operation (best)  0.935 bytes per cycle (best) 	232.495 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  26.393 cycles per operation (best)  8.222 bytes per cycle (best) 	28.287 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  38.095 cycles per operation (best)  5.696 bytes per cycle (best) 	39.111 cycles per operation (avg) 

strlen 218 
Out of 1000 strings, exactly 499 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  34.510 cycles per operation (best)  6.317 bytes per cycle (best) 	37.403 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  240.093 cycles per operation (best)  0.908 bytes per cycle (best) 	240.208 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.944 cycles per operation (best)  7.280 bytes per cycle (best) 	31.187 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.189 cycles per operation (best)  5.424 bytes per cycle (best) 	41.245 cycles per operation (avg) 

strlen 219 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.973 cycles per operation (best)  5.479 bytes per cycle (best) 	44.427 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  274.290 cycles per operation (best)  0.798 bytes per cycle (best) 	274.591 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  33.810 cycles per operation (best)  6.477 bytes per cycle (best) 	36.357 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  48.161 cycles per operation (best)  4.547 bytes per cycle (best) 	53.329 cycles per operation (avg) 

strlen 220 
Out of 1000 strings, exactly 495 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  35.410 cycles per operation (best)  6.213 bytes per cycle (best) 	37.272 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  239.395 cycles per operation (best)  0.919 bytes per cycle (best) 	239.610 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  31.997 cycles per operation (best)  6.876 bytes per cycle (best) 	32.615 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.708 cycles per operation (best)  5.275 bytes per cycle (best) 	42.502 cycles per operation (avg) 

strlen 221 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.554 cycles per operation (best)  5.587 bytes per cycle (best) 	44.434 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  276.973 cycles per operation (best)  0.798 bytes per cycle (best) 	277.291 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  37.104 cycles per operation (best)  5.956 bytes per cycle (best) 	38.297 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  48.960 cycles per operation (best)  4.514 bytes per cycle (best) 	50.147 cycles per operation (avg) 

strlen 222 
Out of 1000 strings, exactly 507 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.102 cycles per operation (best)  5.677 bytes per cycle (best) 	42.025 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  282.772 cycles per operation (best)  0.785 bytes per cycle (best) 	283.074 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  38.897 cycles per operation (best)  5.707 bytes per cycle (best) 	39.866 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  51.262 cycles per operation (best)  4.331 bytes per cycle (best) 	51.970 cycles per operation (avg) 

strlen 223 
Out of 1000 strings, exactly 514 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  37.948 cycles per operation (best)  5.876 bytes per cycle (best) 	43.689 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  287.202 cycles per operation (best)  0.776 bytes per cycle (best) 	287.599 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  40.739 cycles per operation (best)  5.474 bytes per cycle (best) 	41.734 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  51.469 cycles per operation (best)  4.333 bytes per cycle (best) 	52.264 cycles per operation (avg) 

strlen 224 
Out of 1000 strings, exactly 495 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  34.121 cycles per operation (best)  6.565 bytes per cycle (best) 	34.609 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  243.176 cycles per operation (best)  0.921 bytes per cycle (best) 	243.395 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  22.010 cycles per operation (best)  10.177 bytes per cycle (best) 	24.261 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  33.924 cycles per operation (best)  6.603 bytes per cycle (best) 	35.168 cycles per operation (avg) 

strlen 225 
Out of 1000 strings, exactly 496 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  38.915 cycles per operation (best)  5.782 bytes per cycle (best) 	44.049 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  280.163 cycles per operation (best)  0.803 bytes per cycle (best) 	280.387 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.184 cycles per operation (best)  7.710 bytes per cycle (best) 	31.976 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.973 cycles per operation (best)  5.117 bytes per cycle (best) 	44.677 cycles per operation (avg) 

strlen 226 
Out of 1000 strings, exactly 493 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  37.412 cycles per operation (best)  6.041 bytes per cycle (best) 	41.332 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  279.695 cycles per operation (best)  0.808 bytes per cycle (best) 	279.947 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  33.781 cycles per operation (best)  6.690 bytes per cycle (best) 	35.290 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  43.082 cycles per operation (best)  5.246 bytes per cycle (best) 	45.167 cycles per operation (avg) 

strlen 227 
Out of 1000 strings, exactly 489 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  38.742 cycles per operation (best)  5.859 bytes per cycle (best) 	43.759 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  278.593 cycles per operation (best)  0.815 bytes per cycle (best) 	278.631 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  33.710 cycles per operation (best)  6.734 bytes per cycle (best) 	34.777 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.082 cycles per operation (best)  5.035 bytes per cycle (best) 	46.263 cycles per operation (avg) 

strlen 228 
Out of 1000 strings, exactly 497 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.276 cycles per operation (best)  5.805 bytes per cycle (best) 	42.056 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  284.288 cycles per operation (best)  0.802 bytes per cycle (best) 	284.432 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  35.809 cycles per operation (best)  6.367 bytes per cycle (best) 	36.986 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.466 cycles per operation (best)  5.015 bytes per cycle (best) 	46.335 cycles per operation (avg) 

strlen 229 
Out of 1000 strings, exactly 490 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.174 cycles per operation (best)  6.903 bytes per cycle (best) 	37.481 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  246.221 cycles per operation (best)  0.930 bytes per cycle (best) 	246.486 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.462 cycles per operation (best)  7.054 bytes per cycle (best) 	33.799 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.527 cycles per operation (best)  5.651 bytes per cycle (best) 	40.966 cycles per operation (avg) 

strlen 230 
Out of 1000 strings, exactly 502 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  32.904 cycles per operation (best)  6.990 bytes per cycle (best) 	36.901 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  252.985 cycles per operation (best)  0.909 bytes per cycle (best) 	253.291 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  33.403 cycles per operation (best)  6.886 bytes per cycle (best) 	34.324 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.057 cycles per operation (best)  5.469 bytes per cycle (best) 	42.761 cycles per operation (avg) 

strlen 231 
Out of 1000 strings, exactly 494 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  34.072 cycles per operation (best)  6.780 bytes per cycle (best) 	39.224 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  250.391 cycles per operation (best)  0.923 bytes per cycle (best) 	250.737 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.738 cycles per operation (best)  6.650 bytes per cycle (best) 	35.407 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  42.492 cycles per operation (best)  5.436 bytes per cycle (best) 	43.444 cycles per operation (avg) 

strlen 232 
Out of 1000 strings, exactly 513 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.648 cycles per operation (best)  5.851 bytes per cycle (best) 	41.834 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  297.229 cycles per operation (best)  0.781 bytes per cycle (best) 	297.395 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  34.022 cycles per operation (best)  6.819 bytes per cycle (best) 	34.906 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.299 cycles per operation (best)  5.122 bytes per cycle (best) 	46.061 cycles per operation (avg) 

strlen 233 
Out of 1000 strings, exactly 503 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.669 cycles per operation (best)  6.920 bytes per cycle (best) 	38.738 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  256.560 cycles per operation (best)  0.908 bytes per cycle (best) 	256.643 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  28.614 cycles per operation (best)  8.143 bytes per cycle (best) 	30.979 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.309 cycles per operation (best)  5.780 bytes per cycle (best) 	41.428 cycles per operation (avg) 

strlen 234 
Out of 1000 strings, exactly 504 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  37.301 cycles per operation (best)  6.273 bytes per cycle (best) 	41.623 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  294.871 cycles per operation (best)  0.794 bytes per cycle (best) 	301.696 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  35.508 cycles per operation (best)  6.590 bytes per cycle (best) 	36.436 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.406 cycles per operation (best)  4.936 bytes per cycle (best) 	48.113 cycles per operation (avg) 

strlen 235 
Out of 1000 strings, exactly 481 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  37.562 cycles per operation (best)  6.256 bytes per cycle (best) 	43.124 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  283.303 cycles per operation (best)  0.830 bytes per cycle (best) 	283.604 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.337 cycles per operation (best)  6.467 bytes per cycle (best) 	36.652 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.935 cycles per operation (best)  5.116 bytes per cycle (best) 	47.081 cycles per operation (avg) 

strlen 236 
Out of 1000 strings, exactly 501 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.517 cycles per operation (best)  5.972 bytes per cycle (best) 	45.847 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  295.905 cycles per operation (best)  0.798 bytes per cycle (best) 	296.256 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  37.833 cycles per operation (best)  6.238 bytes per cycle (best) 	38.610 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  48.729 cycles per operation (best)  4.843 bytes per cycle (best) 	49.833 cycles per operation (avg) 

strlen 237 
Out of 1000 strings, exactly 512 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  38.595 cycles per operation (best)  6.141 bytes per cycle (best) 	43.949 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  304.399 cycles per operation (best)  0.779 bytes per cycle (best) 	304.756 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  40.349 cycles per operation (best)  5.874 bytes per cycle (best) 	41.465 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  51.344 cycles per operation (best)  4.616 bytes per cycle (best) 	52.297 cycles per operation (avg) 

strlen 238 
Out of 1000 strings, exactly 504 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  35.931 cycles per operation (best)  6.624 bytes per cycle (best) 	44.043 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  299.999 cycles per operation (best)  0.793 bytes per cycle (best) 	300.429 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  39.912 cycles per operation (best)  5.963 bytes per cycle (best) 	40.938 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  49.263 cycles per operation (best)  4.831 bytes per cycle (best) 	50.242 cycles per operation (avg) 

strlen 239 
Out of 1000 strings, exactly 511 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.029 cycles per operation (best)  6.124 bytes per cycle (best) 	44.501 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  305.534 cycles per operation (best)  0.782 bytes per cycle (best) 	305.625 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  41.258 cycles per operation (best)  5.793 bytes per cycle (best) 	42.491 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  53.079 cycles per operation (best)  4.503 bytes per cycle (best) 	53.760 cycles per operation (avg) 

strlen 240 
Out of 1000 strings, exactly 515 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.825 cycles per operation (best)  6.026 bytes per cycle (best) 	41.293 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  309.135 cycles per operation (best)  0.776 bytes per cycle (best) 	309.576 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.798 cycles per operation (best)  8.054 bytes per cycle (best) 	31.890 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  41.498 cycles per operation (best)  5.783 bytes per cycle (best) 	43.383 cycles per operation (avg) 

strlen 241 
Out of 1000 strings, exactly 508 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  34.728 cycles per operation (best)  6.940 bytes per cycle (best) 	39.625 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  267.568 cycles per operation (best)  0.901 bytes per cycle (best) 	267.803 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.728 cycles per operation (best)  7.364 bytes per cycle (best) 	41.708 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.631 cycles per operation (best)  5.168 bytes per cycle (best) 	47.850 cycles per operation (avg) 

strlen 242 
Out of 1000 strings, exactly 502 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  33.821 cycles per operation (best)  7.155 bytes per cycle (best) 	37.618 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  265.656 cycles per operation (best)  0.911 bytes per cycle (best) 	265.896 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  29.514 cycles per operation (best)  8.199 bytes per cycle (best) 	31.446 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  40.212 cycles per operation (best)  6.018 bytes per cycle (best) 	41.523 cycles per operation (avg) 

strlen 243 
Out of 1000 strings, exactly 512 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  40.642 cycles per operation (best)  5.979 bytes per cycle (best) 	46.662 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  310.173 cycles per operation (best)  0.783 bytes per cycle (best) 	314.721 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  37.478 cycles per operation (best)  6.484 bytes per cycle (best) 	38.442 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.361 cycles per operation (best)  5.241 bytes per cycle (best) 	48.320 cycles per operation (avg) 

strlen 244 
Out of 1000 strings, exactly 490 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  37.742 cycles per operation (best)  6.465 bytes per cycle (best) 	46.465 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  297.898 cycles per operation (best)  0.819 bytes per cycle (best) 	298.159 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  35.031 cycles per operation (best)  6.965 bytes per cycle (best) 	36.665 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  45.390 cycles per operation (best)  5.376 bytes per cycle (best) 	46.261 cycles per operation (avg) 

strlen 245 
Out of 1000 strings, exactly 498 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.864 cycles per operation (best)  6.146 bytes per cycle (best) 	46.256 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  304.121 cycles per operation (best)  0.806 bytes per cycle (best) 	304.298 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  37.397 cycles per operation (best)  6.551 bytes per cycle (best) 	39.225 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.778 cycles per operation (best)  5.128 bytes per cycle (best) 	48.905 cycles per operation (avg) 

strlen 246 
Out of 1000 strings, exactly 515 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.882 cycles per operation (best)  6.168 bytes per cycle (best) 	44.042 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  316.139 cycles per operation (best)  0.778 bytes per cycle (best) 	316.273 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  40.501 cycles per operation (best)  6.074 bytes per cycle (best) 	41.375 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  52.015 cycles per operation (best)  4.729 bytes per cycle (best) 	52.777 cycles per operation (avg) 

strlen 247 
Out of 1000 strings, exactly 516 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.681 cycles per operation (best)  6.225 bytes per cycle (best) 	45.673 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  317.447 cycles per operation (best)  0.778 bytes per cycle (best) 	317.636 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  41.182 cycles per operation (best)  5.998 bytes per cycle (best) 	42.009 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  51.483 cycles per operation (best)  4.798 bytes per cycle (best) 	52.732 cycles per operation (avg) 

strlen 248 
Out of 1000 strings, exactly 490 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.816 cycles per operation (best)  6.229 bytes per cycle (best) 	42.060 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  303.132 cycles per operation (best)  0.818 bytes per cycle (best) 	303.581 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  32.839 cycles per operation (best)  7.552 bytes per cycle (best) 	33.954 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  44.255 cycles per operation (best)  5.604 bytes per cycle (best) 	45.786 cycles per operation (avg) 

strlen 249 
Out of 1000 strings, exactly 505 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  40.713 cycles per operation (best)  6.116 bytes per cycle (best) 	46.695 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  313.769 cycles per operation (best)  0.794 bytes per cycle (best) 	313.927 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.146 cycles per operation (best)  6.889 bytes per cycle (best) 	37.171 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.915 cycles per operation (best)  5.307 bytes per cycle (best) 	47.814 cycles per operation (avg) 

strlen 250 
Out of 1000 strings, exactly 504 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  38.512 cycles per operation (best)  6.491 bytes per cycle (best) 	42.492 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  313.356 cycles per operation (best)  0.798 bytes per cycle (best) 	313.656 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  36.492 cycles per operation (best)  6.851 bytes per cycle (best) 	38.125 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  46.488 cycles per operation (best)  5.378 bytes per cycle (best) 	48.492 cycles per operation (avg) 

strlen 251 
Out of 1000 strings, exactly 489 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.126 cycles per operation (best)  6.415 bytes per cycle (best) 	44.288 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  305.358 cycles per operation (best)  0.822 bytes per cycle (best) 	305.570 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  35.594 cycles per operation (best)  7.052 bytes per cycle (best) 	36.779 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.322 cycles per operation (best)  5.304 bytes per cycle (best) 	48.313 cycles per operation (avg) 

strlen 252 
Out of 1000 strings, exactly 489 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  34.754 cycles per operation (best)  7.251 bytes per cycle (best) 	37.733 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  268.098 cycles per operation (best)  0.940 bytes per cycle (best) 	268.264 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  37.777 cycles per operation (best)  6.671 bytes per cycle (best) 	43.698 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  47.806 cycles per operation (best)  5.271 bytes per cycle (best) 	48.709 cycles per operation (avg) 

strlen 253 
Out of 1000 strings, exactly 506 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.882 cycles per operation (best)  6.344 bytes per cycle (best) 	46.190 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  318.376 cycles per operation (best)  0.795 bytes per cycle (best) 	318.664 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  39.126 cycles per operation (best)  6.466 bytes per cycle (best) 	40.326 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  48.606 cycles per operation (best)  5.205 bytes per cycle (best) 	50.393 cycles per operation (avg) 

strlen 254 
Out of 1000 strings, exactly 494 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  38.808 cycles per operation (best)  6.545 bytes per cycle (best) 	45.086 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  312.333 cycles per operation (best)  0.813 bytes per cycle (best) 	312.829 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  41.601 cycles per operation (best)  6.106 bytes per cycle (best) 	42.142 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  50.340 cycles per operation (best)  5.046 bytes per cycle (best) 	51.407 cycles per operation (avg) 

strlen 255 
Out of 1000 strings, exactly 511 are identical.
mass_comparison(bigarray1, bigarray2, N, strlen)            	:  39.447 cycles per operation (best)  6.464 bytes per cycle (best) 	44.781 cycles per operation (avg) 
simple_mass_comparison(bigarray1, bigarray2, N, strlen)     	:  323.314 cycles per operation (best)  0.789 bytes per cycle (best) 	323.596 cycles per operation (avg) 
avx_mass_comparison(bigarray1, bigarray2, N, strlen)        	:  42.368 cycles per operation (best)  6.019 bytes per cycle (best) 	43.306 cycles per operation (avg) 
avxmemcmp_mass_comparison(bigarray1, bigarray2, N, strlen)  	:  53.113 cycles per operation (best)  4.801 bytes per cycle (best) 	54.387 cycles per operation (avg) 

