The originnal program was written in VisualStudio C++ (various versions over the years) and more or less  a standalone program, 
you input the specification of the code and after some churning, it spew out a .h file ( with both encoding matrix and 
decoding/Synddrome matrix ) ready to be included in a test program.  This has here been broken into a smaller steps,
to improve understanding and add some well defined points, where different methods  or improvements  can be tested.

Two kinds of codes can be generated:  Regular codes, where each databit participates in a fixed number of parity checks and
Irregular codes, where a few of the databits participates in additional parity checks, acting like a kind of super-witnesses, 
and giving slightly better  performance  than the regular code.  You will have both available at the end of the process, we
modify a Regular code to be an Irregular for easy comparison.

the proces is a follows :

Generate a  raw-inputfile based on a few parameters suppliced by the user :   

                                step1 >  file1   ; file1 will contain  the specification of a binary matrix, with N columns
                                                 ; (one for each data and parity bit) and K rows (one for each parity check).
                                                                                                                                                                                                                          
Convert file to a Gallagher/LDPC code, which permutes a subset of the columns/rows to ensurate that the parity matrix (the last 
N-K columns ) is non-singular and sparse in most columns. A small subset (you decide on count)  of columns will be non-sparse:

                                step2  file1 > file2   	; file2 contains  a new binary matrix, with N columns and K rows.  
                                                       	; It is a combination of a (N-K)xK data matrix (used for encoding)  
														; and a Kx K non-singular Parity Check matrix (used for decoding and 
														; Syndrome calculation).
                                                       	; it also contains the LU factoring of the parity check matrix, 
														; permitting fast encoding.                                                                                                                                 

Convert this file to source code, in this case  a .h file, where the various bits are conditionally compiled, depending 
on whether you want make an encoder or a decoder:                                                                                  

                                step3 file2  > file3

Now you have a Regular LDPC/Gallagher code, ready for testing and validation.
                                                                                                                                                                   
If you want to make an Sligthly Irregular LDPC code your insert a further step between step2 and step3
                                                                                                                                                                   
                                step2i  file2 > file2i  ; it augments the data part of the matrix, so some bits participates
														; in more checks than most, this adds a small
                                                        ; improvement in correction performance.

You generate the code file in the same way and with the same program as for regular LDPC files.

                                 step3 file2i > file3