Brutal force
speed is
50000000-100000000
combinations checks per second

 

Download demo version mls7demo.rar

Application is only 200kb (users gude takes much more spaces)
In this demo version you can test all to see how program is working but you can not change total number value bigger then 13.

Price for it is only $15
You can pay for it using PayPal.
You will get it in max of 48h

Demo video building 7/12,guarantee 5

 

My Lotto System
version 1.3 (2012.)

(for 7 numbers per combination)

 

 

This is very easy to use application to generate abbreviated lotto systems up to 39 numbers in total. You can design your own system and check every time what is going on, how many combinations are covered, view statistics of numbers in uncovered combinations, and actually see uncovered cmbinations.We will calculate all relevant values.
Sometimes full abbreviated systems for large total number can be expensive so you can cat that number down by 50% and keep probability above 90% of covered combinations. You have full control how your system will be, and how efficient it will be.


All generating's routines are written in assembler, so you can expect speed of more then 50000000-100000000 combinations checks per seconds on 3GHz dual core.We will use all the power of your PC to get the job done.

Rread short users guide and see for yourself how to use this little application.

NEW version 1.4 will be avaliable soon
little bit faster and with more options
users of older versions will get it for free
(screen of new version)

You can buy it and download full version in a minute



This 100% secure and safe for you.

 

Demo video building 7/15,guarantee 5 (95%)


What you can do with this application?

For example...
You can build your system from the start or you can enter some lottery system of your choice and try to extend it
to larger total numbers in the pool.
This is very usefully when you want to cover large total systems (20 numbers and up). You know that
full system is big, sometimes abbreviated with 100% guarantee of winning smaller prizes are big too.
Now you can build your own system with guarantee smaller then 100% but you can keep it near the value you want.

For example just to be clear. You know that full system of 20 numbers has 77520 combinations of 7 numbers.
Reduced system that will guarantee 100% 5 hits has 138 combinations.
But now you can play ONLY around 50 combinations and have more then 80% 5 hits if you have 7 numbers between you 20.
Reduced system with 100% guarantee 5 from 22 numbers has 248 combinations
but you can play around 100 combinations and have more then 80% 5 hits if you have 7 numbers between you 22.

All of these upper values are for you info only, you can build better solutions, and these solutions will be yours 100%.
Just play with this application and build your own systems with guarantee you want.

Very easy you can build full abbreviated system with 100% guarantee too, downlod demo and you will for example
find some abbreviated system like that you will like
Build your own with probability and size you want.




You can design very interesting reduced lotto systems,
for example here is one of 15 numbers,
with 100% guaratee of 5,
THIS SYSTEM HAS 25 COMBINATIONS



One more important example
for what you can use this application.

On internet, for example on site www.lottery.co.rs you can find next reduced system
(find it under Partial lottery wheels for 7 numbers per combination)

total numbers in system 18
number per combination 7
guarantee 5
partial cover 93.42%
number of combinations 40

and we can say that this is very good reduced system

But is there something that we can do with it and make it better?
If you import this system in our application you can check it and you will really get this nice result.

But ih you check it against only 10 numbers you will see that there is no 100% guarantee for that case, one combination
is missing. Our application will help you and you will find that you must add next one

1,4,6,7,8,9,10

and now you will have
100% covering for 10 numbers and 93.744% partial cover for system of 18 numbers.


We can do similar tests for other cases
check 11 numbers
uncoverad combinations in that case are 5
add next one combination to fix that
1,2,4,8,9,10,11
and now you will have
100% covering for 11 numbers and 93.649% partial cover for system of 18 numbers.

check 12 numbers
uncoverad combinations in that case are 43
add next 3 combinations to fix that
1,2,3,5,6,8,12
4,6,7,8,9,10,12
2,3,4,8,9,11,12
and now you will have
100% covering for 12 numbers and 94.325% partial cover for system of 18 numbers.

check 13 numbers
uncoverad combinations in that case are 84
add next 5 combinations to fix that
2,3,4,5,8,11,13
4,6,7.8,9,10,12
1,2,5,6,7,12,13
1,2,5,9,10,11,13
1,3,4,5,6,8,10


and now you will have
100% covering for 13 numbers and for 18 ... well you will see...

Thi is only one example for what our application can be used

And now small gift...Some lottery functions for software developers.

You can get source code for this application (price is $200, contact me if you want it),
so you can build your own lottery application.
This application is build using PowerBasic compiler. BASIC???
Please read this just a little bit more.
I know that many programmers don't like to hear BASIC, but this is only in public, because this tool is very, very powerfully and many people like to call it "programmers secret weapon", try it and you will know why. I will show you here full source code with function how to generate
all combinations (full wheels) for lottery games with up to 8 numbers per combination from up to 64.... numbers (memory that you can use inside windows application is limited, so...). You can easily extend this function to support up to 16 numbers per combination, but I will leave it to you. Because sometimes programmers use bit representation of combination here you will find how to generate all combinations from up to 8 numbers per combination, from up to 64 numbers, so we will represent combinations with 64 bits. This is all for win32 but we will use some 64bits registers (mmx) so all of this can be done with acceptable speed. I must say that this functions are very small, as you will see, but also they are very fast. And you will see powerbasic in action.

 

 

#COMPILE DLL
#DIM ALL
#INCLUDE ONCE "Win32API.inc"
GLOBAL ghInstance AS DWORD

'-------------------------------------------------------------------------------
' Main DLL entry point called by Windows...
'
FUNCTION LIBMAIN (BYVAL hInstance AS LONG, _
BYVAL fwdReason AS LONG, _
BYVAL lpvReserved AS LONG) AS LONG

SELECT CASE fwdReason

CASE %DLL_PROCESS_ATTACH
'Indicates that the DLL is being loaded by another process (a DLL
'or EXE is loading the DLL). DLLs can use this opportunity to
'initialize any instance or global data, such as arrays.

ghInstance = hInstance

FUNCTION = 1 'success!

'FUNCTION = 0 'failure! This will prevent the EXE from running.

CASE %DLL_PROCESS_DETACH
'Indicates that the DLL is being unloaded or detached from the
'calling application. DLLs can take this opportunity to clean
'up all resources for all threads attached and known to the DLL.

FUNCTION = 1 'success!

'FUNCTION = 0 'failure!

CASE %DLL_THREAD_ATTACH
'Indicates that the DLL is being loaded by a new thread in the
'calling application. DLLs can use this opportunity to
'initialize any thread local storage (TLS).

FUNCTION = 1 'success!

'FUNCTION = 0 'failure!

CASE %DLL_THREAD_DETACH
'Indicates that the thread is exiting cleanly. If the DLL has
'allocated any thread local storage, it should be released.

FUNCTION = 1 'success!

'FUNCTION = 0 'failure!

END SELECT

END FUNCTION

'******************************************************************************************
' OUR FUNCTION ASLottoGen
'parameters:
' myTotalNum - total number in system (up to 64)
' myNumInComb - numbers per combination ( from 1 to 8)
' where2put - pointer to memory where we will store combinations
' one byte per number, and combination will be stored one by one
'******************************************************************************************

FUNCTION ASLottoGen ALIAS "ASLottoGen" _
(BYVAL myTotalNum AS LONG, BYVAL myNumInComb AS LONG, _
BYVAL where2put AS LONG) EXPORT AS LONG
#REGISTER NONE
DIM my_1comb(16) AS BYTE
'place where we have current combination from 'my_1comb(1)...my_1comb(myNumInComb). Tthis array must have size of 16 bytes, for combination we use only 'smaller part but because we transfer 8 bytes every time when we step from one combination to another
'we need some extra space

DIM ptr2_my_1comb AS LONG 'pointer to first elemet of our array
DIM num_combs AS LONG 'we will return value in this variable

ptr2_my_1comb=VARPTR(my_1comb(0))
' ****************************
' OUR FUNCTION START FROM HERE
'*****************************
! push esi
! push edi
! push ebx

! mov eax,where2put ; we will keep these values in our mmx registers
! movd mm1,eax ;in mm1 is pointer where we must store our combinations
! mov ebx,myTotalNum
! movd mm2,ebx ;in mm2 is myTotalNum
! mov ecx,myNumInComb
! movd mm3,ecx ;in mm3 is myNumInComb

! lea edi,mynumberlist ;in edi is pointer to our numbers list
! movq mm0,[edi+1]
! mov esi,ptr2_my_1comb
! movq [esi+1],mm0 ;we will have 1. combination in place

! xor edx,edx ;in edx we will keep counter of combinations, start from 0
! xor eax,eax ;because we must use al (part of eax) we will set it to 0
! je store_comb ;store combinations and increase counter

'**************************************
' the hart of generator, code start here
'**************************************
loop_lotto:
! mov al,[esi+ecx]
! inc eax
! cmp eax,ebx
! jbe next_comb
! dec ebx
! dec ecx
! jne loop_lotto
! jmp gencomb_end

next_comb:
! movq mm0,[edi+eax]
! movq [esi+ecx],mm0
'**********************
' generator code end here,
'**********************
' now combination is ready
'**********************
store_comb:
! movq mm0,[esi+1]
! movd ebx,mm1
! movq [ebx],mm0

! movd ecx,mm3
! add ebx,ecx
! movd mm1,ebx
! movd ebx,mm2
! inc edx
! jne loop_lotto
gencomb_end:
! emms
! mov num_combs,edx
! pop ebx
! pop edi
! pop esi
FUNCTION=num_combs
END FUNCTION
ASMDATA mynumberlist
DB 0,1,2,3,4,5,6,7,8,9,10
DB 11,12,13,14,15,16,17,18,19,20
DB 21,22,23,24,25,26,27,28,29,30
DB 31,32,33,34,35,36,37,38,39,40
DB 41,42,43,44,45,46,47,48,49,50
DB 51,52,53,54,55,56,57,58,59,60
DB 61,62,63,64
END ASMDATA

'**************************************************************
' Function ASLottoGen64B
' myTotalNum - total number in system (up to 64)
' myNumInComb - numbers per combination ( from 1 to 8)
' where2put - pointer to memory where we will store combinations
' we will have 8bytes per combination, one by one,
'each combination will be represented as 64bit vaue
'**************************************************************

FUNCTION ASLottoGen64B alias "ASLottoGen64B" (BYVAL myTotalNum AS LONG,_
BYVAL myNumInComb AS LONG,BYVAL where2put AS LONG) EXPORT AS LONG
#REGISTER NONE
DIM my_1comb(32) AS BYTE
DIM ptr2_my_1comb AS LONG
DIM my_currentb64(8) AS QUAD
DIM ptr2_my_currentb64 AS LONG

ptr2_my_1comb=VARPTR(my_1comb(0))
ptr2_my_currentb64=VARPTR(my_currentb64(0))

' *********************************
' OUR FUNCTION START FROM HERE
'*********************************
! push esi
! push edi
! push ebx

! mov eax,where2put
! movd mm1,eax
;in mm1 is pointer where we must store our combiations

! lea esi,start64b
! mov edi,ptr2_my_currentb64
! movd mm5,edi
;in mm5 is pointer to my_currentb64

! mov ecx,myNumInComb ;just to calculate how many quads we must take
! mov eax,8
! mul ecx
! mov edx,eax
! mov ecx,8

take_again:
! movq mm7,[esi+ecx]
! movq [edi+ecx],mm7
! add ecx,8
! sub edx,8
! jne take_again

! mov ebx,myTotalNum
! movd mm2,ebx ;in mm2 is myTotalNum
! mov ecx,myNumInComb
! movd mm3,ecx ;
in mm3 is myNumInComb
! lea eax,my64numbers
! movd mm4,eax ;in mm4 is pointer to my64numbers list
! lea edi,mynumberlist ;in edi is pointer to our numbers list
! movq mm0,[edi+1]
! mov esi,ptr2_my_1comb
! movq [esi+1],mm0
;we will have 1. combination in place
! movq mm0,[edi+9]
! movq [esi+9],mm0

! xor eax,eax ;because we must use al (part of eax) we will set it to 0
! je store_comb ;store bitmap representation
loop_lotto:
! mov al,[esi+ecx]
! inc eax
! cmp eax,ebx
! jbe next_comb
! dec ebx
! dec ecx
! jne loop_lotto
! jmp gencomb_end

next_comb:
! movq mm0,[edi+eax]
! movq [esi+ecx],mm0
'---------------------------------------------------------------
' now we will make 64bits representation of current combination
'---------------------------------------------------------------
! push esi ;we will save registers that we will use in next commands
! push edi

! movd esi,mm4 ;esi=pointer to my64numbers list
! movd edi,mm5 ;edi=ptr2_my_currentb64
! dec ecx ;ecx=ecx-1
! movq mm6,[edi+ecx*8] ;load bit representation for numbers from position 1 to ecx
! mov ebx,8 ;number in eax is multiply by 8, to locate its representation
! mul ebx
! movd ebx,mm3 ;ebx=myNumInComb
! inc ecx ;ecx=ecx+1

set_my_currentb64a:
! movq mm7,[esi+eax]
;mm7=bit represenation of number in eax
! por mm7,mm6 ;we will add that bit
! movq [edi+ecx*8],mm7 ;store it in working function memory
! movq mm6,mm7 ;we will remember it in mm6
! add eax,8 ;we need next representation
! inc ecx ;ecx=ecx+1
! cmp ecx,ebx ;are we done with combination?
! jbe set_my_currentb64a
! pop edi
! pop esi

'*********************************
' combination is ready and bitmap is in mm7
'*********************************
store_comb:
! movd ebx,mm1

! movq [ebx],mm7 ;in mm7 we have our bit representation and we will store it in calling function memory
! add ebx,8
! movd mm1,ebx

! movd ecx,mm3
! movd ebx,mm2
! xor eax,eax
! je loop_lotto
gencomb_end:
! emms
! pop ebx
! pop edi
! pop esi
END FUNCTION
ASMDATA start64b
DB 0,0,0,0,0,0,0,0
DB 1,0,0,0,0,0,0,0
DB 3,0,0,0,0,0,0,0
DB 7,0,0,0,0,0,0,0
DB 15,0,0,0,0,0,0,0
DB 31,0,0,0,0,0,0,0
DB 63,0,0,0,0,0,0,0
DB 127,0,0,0,0,0,0,0
END ASMDATA
ASMDATA my64numbers
DB 0,0,0,0,0,0,0,0
DB 1,0,0,0,0,0,0,0
DB 2,0,0,0,0,0,0,0
DB 4,0,0,0,0,0,0,0
DB 8,0,0,0,0,0,0,0
DB 16,0,0,0,0,0,0,0
DB 32,0,0,0,0,0,0,0
DB 64,0,0,0,0,0,0,0
DB 128,0,0,0,0,0,0,0

DB 0,1,0,0,0,0,0,0
DB 0,2,0,0,0,0,0,0
DB 0,4,0,0,0,0,0,0
DB 0,8,0,0,0,0,0,0
DB 0,16,0,0,0,0,0,0
DB 0,32,0,0,0,0,0,0
DB 0,64,0,0,0,0,0,0
DB 0,128,0,0,0,0,0,0

DB 0,0,1,0,0,0,0,0
DB 0,0,2,0,0,0,0,0
DB 0,0,4,0,0,0,0,0
DB 0,0,8,0,0,0,0,0
DB 0,0,16,0,0,0,0,0
DB 0,0,32,0,0,0,0,0
DB 0,0,64,0,0,0,0,0
DB 0,0,128,0,0,0,0,0

DB 0,0,0,1,0,0,0,0 '25
DB 0,0,0,2,0,0,0,0 '26
DB 0,0,0,4,0,0,0,0 '27
DB 0,0,0,8,0,0,0,0 '28
DB 0,0,0,16,0,0,0,0 '29
DB 0,0,0,32,0,0,0,0 '30
DB 0,0,0,64,0,0,0,0 '31
DB 0,0,0,128,0,0,0,0 '32

DB 0,0,0,0,1,0,0,0 '33
DB 0,0,0,0,2,0,0,0 '34
DB 0,0,0,0,4,0,0,0 '35
DB 0,0,0,0,8,0,0,0 '36
DB 0,0,0,0,16,0,0,0 '37
DB 0,0,0,0,32,0,0,0 '38
DB 0,0,0,0,64,0,0,0 '39
DB 0,0,0,0,128,0,0,0 '40

DB 0,0,0,0,0,1,0,0
DB 0,0,0,0,0,2,0,0
DB 0,0,0,0,0,4,0,0
DB 0,0,0,0,0,8,0,0
DB 0,0,0,0,0,16,0,0
DB 0,0,0,0,0,32,0,0
DB 0,0,0,0,0,64,0,0
DB 0,0,0,0,0,128,0,0

DB 0,0,0,0,0,0,1,0
DB 0,0,0,0,0,0,2,0
DB 0,0,0,0,0,0,4,0
DB 0,0,0,0,0,0,8,0
DB 0,0,0,0,0,0,16,0
DB 0,0,0,0,0,0,32,0
DB 0,0,0,0,0,0,64,0
DB 0,0,0,0,0,0,128,0

DB 0,0,0,0,0,0,0,1
DB 0,0,0,0,0,0,0,2
DB 0,0,0,0,0,0,0,4
DB 0,0,0,0,0,0,0,8
DB 0,0,0,0,0,0,0,16
DB 0,0,0,0,0,0,0,32
DB 0,0,0,0,0,0,0,64
DB 0,0,0,0,0,0,0,128
DB 0,0,0,0,0,0,0,0
END ASMDATA

 

 

And you sow, this is PowerBasic inline assembler in action.When you buy source code for MLS7 you will get something like this, and this is still PowerBasic.

Save this text in file for example in MyLottogenerator.bas, compile it and you will get DLL with these two functions in it. These functions are in public domain, and they are small and very fast. I must say that similar functions that you will see in source code of MLS7 are much, much faster. That is the reason why I put these functions in public in the first place.
PowerBasic is nice tool and it has buildin inline assembler support, so this all can be done using all the power of PC's these days.

 

If you use C#, here is one simple example how to call function ASLottoGen. In your main program you need to define memory space and send pointer to it, we will fill it with numbers.If library with upper function have name testdll.dll (change this with name you set for it) you can use it this way.

 

// file test4ASLottoGen.cs
// compile with: /unsafe
using System;
using System.Text;
using System.Runtime.InteropServices;

class Test
{
// The unsafe keyword allows pointers to be used within
// the following method:
[DllImport("testdll", SetLastError = true)]
static extern unsafe uint ASLottoGen(uint n, uint n1, byte* p);

static void Main(string[] args)
{
byte[] combs = new byte[110000000];
uint ncomb;
unsafe
{
fixed (byte* pcombs = combs) ASLottoGen(39, 7, pcombs);
}
Console.WriteLine("First combination of 7/39 system ");
ncomb = 1;
for (int i = 0; i < 7; i++)
Console.Write(combs[(ncomb - 1) * 7 + i] + " ");
Console.WriteLine("\n");

Console.WriteLine("Last combination of 7/37 system ");
ncomb = 15380937;
for (int i = 0; i < 7; i++)
Console.Write(combs[(ncomb - 1) * 7 + i] + " ");
Console.WriteLine("\n");

}
}

 

Copyright © 2012. AS Computer Software


All Rights Reserved