#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ stderr;
void display_usage() {
  fprintf(stderr, "Usage: djent [-brRpcCuhds] [-l <n>] [-i <input file list "
                  "filename>] [filename] [filename2] ...\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "Compute statistics of random data.\n");
  fprintf(stderr, "  Author: David Johnston, dj@deadhat.com\n");
  fprintf(stderr, "\n");
  fprintf(stderr, "  -i <filename>  --inputfilelist=<filename> Read list of "
                  "filenames from <filename>\n");
  fprintf(stderr, "  -p             --parse_filename           Extract CID, "
                  "Process, Voltage and Temperature from filename.\n");
  fprintf(stderr, "                                            The values will "
                  "be included in the output.\n");
  fprintf(stderr, "  -l <n>         --symbol_length=<n>        Treat incoming "
                  "data symbols as bitlength n. Default is 8.\n");
  fprintf(stderr, "  -b             --binary                   Treat incoming "
                  "data as binary. Default bit length will be -l 1\n");
  fprintf(stderr, "  -r             --byte_reverse             Reverse the bit "
                  "order in incoming bytes\n");
  fprintf(stderr, "  -R             --word_reverse             Reverse the "
                  "byte order in incoming 4 byte words\n");
  fprintf(stderr, "  -c             --occurrence               Print symbol "
                  "occurrence counts\n");
  fprintf(stderr, "  -C             --longest                  Print symbol "
                  "longest run counts\n");
  fprintf(stderr, "  -w             --scc_wrap                 Treat data as "
                  "cyclical in SCC\n");
  fprintf(stderr, "  -n <n>         --lagn=<n>                 Lag gap in SCC. "
                  "Default=1\n");
  fprintf(stderr, "  -S <n>         --skip=<n>                 Skip over <n> "
                  "initial symbols\n");
  fprintf(stderr, "  -L <n>         --substring=<n>            Analyse no more "
                  "that <n> symbols\n");
  fprintf(stderr, "  -f             --fold                     Fold uppercase "
                  "letters to lower case\n");
  fprintf(stderr, "  -t             --terse                    Terse output\n");
  fprintf(stderr, "  -e             --ent_exact                Exactly match "
                  "output format of ent\n");
  fprintf(stderr, "  -s             --suppress_header          Suppress the "
                  "header in terse output\n");
  fprintf(stderr,
          "  -h or -u       --help                     Print this text\n");
  fprintf(stderr, "\n Notes\n");
  fprintf(stderr, "   * By default djent is in hex mode where it reads ascii "
                  "hex data and converts it to binary to analyze.\n");
  fprintf(stderr, "     In hex mode, the symbol length defaults to 8, so "
                  "normal hex files can be treated as a representation\n");
  fprintf(stderr, "     of bytes. The symbol length can be changed to any "
                  "value between 1 and 32 bits using the -l <n> option.\n");
  fprintf(stderr, "   * With the -b option djent switches to binary reads in "
                  "each byte as binary with a symbol length of 1.\n");
  fprintf(stderr, "   * To analyze ascii text instead of hex ascii, you need "
                  "djent to treat each byte as a separate symbol, so\n");
  fprintf(stderr, "     use binary mode with a symbol length of 8. I.E. djent "
                  "-b -l 8 <filename>\n");
  fprintf(stderr, "   * By default djent treats the MSB of each byte as the "
                  "first. This can be switched so that djent treats\n");
  fprintf(stderr,
          "     the LSB as the first bit in each byte using the -r option.\n");
  fprintf(stderr, "   * Terse output is requested using -t. This outputs in "
                  "CSV format. The first line is the header. If\n");
  fprintf(stderr, "     multiple files are provided, there will be one line of "
                  "CSV output per file in addition to the header.\n");
  fprintf(stderr, "     The CSV header can be suppressed with -s.\n");
  fprintf(stderr, "   * To analyze multiple files, just give multiple file "
                  "names on the command line. To read data in from\n");
  fprintf(stderr, "     the command line, don't provide a filename and pipe "
                  "the data in. <datasource> | djent\n");
  fprintf(stderr, "   * The parse filename option =p picks takes four patterns "
                  "from the filename to include in the output,\n");
  fprintf(stderr, "     This is so that it is easy to plot test conditions "
                  "that are commonly encoded in a filename.\n");
  fprintf(stderr, "     Fields are delimited by uderscores. The four patters "
                  "for CID, process, Voltage and Temperature are:\n");
  fprintf(stderr, "     _CID-<componentID>_ , _PROC-<process info>_, "
                  "_<x>p<y>V_ and _<x>p<y>C_ . 'p' is the decimal point.\n");
  fprintf(stderr, "   * To compute the statistics, djent builds a frequency "
                  "table of the symbols. This can be displayed\n");
  fprintf(stderr, "     using the -c option. The size of this table is what "
                  "limits the the maximum symbol size. For each\n");
  fprintf(stderr, "     of the 2^n symbols, a 64 bit entry in a table is "
                  "created. So for n=32, that's 32GBytes so the ability\n");
  fprintf(stderr, "     to handle large symbol sizes is limited by the "
                  "available memory and the per process allocation limit.\n");
  fprintf(stderr, "   * The serial correlation coefficient is not wrap around "
                  "by default, meaning that it does not compare\n");
  fprintf(stderr, "     the last value in the data with the first. To get wrap "
                  "around behaviour, use the -w option.\n");
  fprintf(stderr, "   * The Lag-N correlation coefficient can be computed by "
                  "using the -n <n> option. This causes the SCC\n");
  fprintf(stderr, "     computation to compare each Xth symbol with the "
                  "(X+n)th symbol instead of the (X+1)th symbol.\n");
  fprintf(stderr, "     If you use wrap around with Lag-N, then the wrap "
                  "around will reach n bits further into the start\n");
  fprintf(stderr, "     of the sequence.\n");
  fprintf(stderr, "   * The byte reverse option -r reverses the order of bits "
                  "within each byte. The word reverse option -R\n");
  fprintf(stderr, "     reverses the order of bytes within each 32 bit word, "
                  "from 3,2,1,0 to 0,1,2,3. Both -R and -r can\n");
  fprintf(stderr, "     be used together. Using -R with a data that isn't a "
                  "multiple of 32 bits long will get padded with\n");
  fprintf(stderr, "     zeros, which may not be what you want. A padding "
                  "warning will be sent to STDERR.\n");
  fprintf(stderr, "   * Instead of providing data file names on the command "
                  "line, djent can be told to read a list of files\n");
  fprintf(stderr, "     from a text file. The file must have one filename per "
                  "line. Lines beginning with # will be ignored.\n");
  fprintf(stderr, "     Use the -i <filename> option to request that djent "
                  "reads the file list from <filename>.\n");
  fprintf(stderr, "\n Examples\n");
  fprintf(stderr, "   Print this help\n");
  fprintf(stderr, "     djent -h\n\n");
  fprintf(stderr, "   Analyze hex file from stdin\n");
  fprintf(stderr, "     cat datafile.hex | djent\n\n");
  fprintf(stderr, "   Analyze binary file\n");
  fprintf(stderr, "     djent -b datafile.bin\n\n");
  fprintf(stderr, "   Analyze several files with CSV output\n");
  fprintf(stderr, "     djent -t data1.hex data2.hex data3.hex\n\n");
  fprintf(
      stderr,
      "   Analyze ascii symbols - Read in binary and set symbol size to 8.\n");
  fprintf(stderr, "     djent -b -l 8  textfile.txt\n\n");
  fprintf(stderr, "   Analyze binary file with parsable filename.\n");
  fprintf(stderr,
          "     djent -b -t -p  rawdata_CID-X23_PROC-TTFT_1p2V_25p0C_.bin\n");
}


x86 assembly (clang, -O0):
<display_usage>:
push   %rbp
mov    %rsp,%rbp
mov    0x3ec5(%rip),%rax
mov    (%rax),%edi
lea    0xedc(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3eb0(%rip),%rax
mov    (%rax),%edi
lea    0x226a(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e9b(%rip),%rax
mov    (%rax),%edi
lea    0xf12(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e86(%rip),%rax
mov    (%rax),%edi
lea    0xf21(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e71(%rip),%rax
mov    (%rax),%edi
lea    0x222b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e5c(%rip),%rax
mov    (%rax),%edi
lea    0xf21(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e47(%rip),%rax
mov    (%rax),%edi
lea    0xf60(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e32(%rip),%rax
mov    (%rax),%edi
lea    0xfb5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e1d(%rip),%rax
mov    (%rax),%edi
lea    0xff8(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3e08(%rip),%rax
mov    (%rax),%edi
lea    0x104a(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3df3(%rip),%rax
mov    (%rax),%edi
lea    0x10a1(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3dde(%rip),%rax
mov    (%rax),%edi
lea    0x10e1(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3dc9(%rip),%rax
mov    (%rax),%edi
lea    0x1129(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3db4(%rip),%rax
mov    (%rax),%edi
lea    0x1160(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d9f(%rip),%rax
mov    (%rax),%edi
lea    0x1198(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d8a(%rip),%rax
mov    (%rax),%edi
lea    0x11ce(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d75(%rip),%rax
mov    (%rax),%edi
lea    0x1200(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d60(%rip),%rax
mov    (%rax),%edi
lea    0x1236(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d4b(%rip),%rax
mov    (%rax),%edi
lea    0x126f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d36(%rip),%rax
mov    (%rax),%edi
lea    0x12ac(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d21(%rip),%rax
mov    (%rax),%edi
lea    0x12d1(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3d0c(%rip),%rax
mov    (%rax),%edi
lea    0x130c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3cf7(%rip),%rax
mov    (%rax),%edi
lea    0x1348(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ce2(%rip),%rax
mov    (%rax),%edi
lea    0x1370(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ccd(%rip),%rax
mov    (%rax),%edi
lea    0x1364(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3cb8(%rip),%rax
mov    (%rax),%edi
lea    0x13b9(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ca3(%rip),%rax
mov    (%rax),%edi
lea    0x140f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c8e(%rip),%rax
mov    (%rax),%edi
lea    0x1467(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c79(%rip),%rax
mov    (%rax),%edi
lea    0x14bc(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c64(%rip),%rax
mov    (%rax),%edi
lea    0x1514(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c4f(%rip),%rax
mov    (%rax),%edi
lea    0x154e(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c3a(%rip),%rax
mov    (%rax),%edi
lea    0x15a4(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c25(%rip),%rax
mov    (%rax),%edi
lea    0x15d0(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3c10(%rip),%rax
mov    (%rax),%edi
lea    0x1622(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3bfb(%rip),%rax
mov    (%rax),%edi
lea    0x1679(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3be6(%rip),%rax
mov    (%rax),%edi
lea    0x1694(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3bd1(%rip),%rax
mov    (%rax),%edi
lea    0x16e8(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3bbc(%rip),%rax
mov    (%rax),%edi
lea    0x172f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ba7(%rip),%rax
mov    (%rax),%edi
lea    0x1783(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b92(%rip),%rax
mov    (%rax),%edi
lea    0x17d0(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b7d(%rip),%rax
mov    (%rax),%edi
lea    0x1825(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b68(%rip),%rax
mov    (%rax),%edi
lea    0x1879(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b53(%rip),%rax
mov    (%rax),%edi
lea    0x18ca(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b3e(%rip),%rax
mov    (%rax),%edi
lea    0x191c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b29(%rip),%rax
mov    (%rax),%edi
lea    0x1973(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3b14(%rip),%rax
mov    (%rax),%edi
lea    0x19ca(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3aff(%rip),%rax
mov    (%rax),%edi
lea    0x1a1e(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3aea(%rip),%rax
mov    (%rax),%edi
lea    0x1a6b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ad5(%rip),%rax
mov    (%rax),%edi
lea    0x1abe(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3ac0(%rip),%rax
mov    (%rax),%edi
lea    0x1b0d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3aab(%rip),%rax
mov    (%rax),%edi
lea    0x1b5f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a96(%rip),%rax
mov    (%rax),%edi
lea    0x1b61(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a81(%rip),%rax
mov    (%rax),%edi
lea    0x1bb5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a6c(%rip),%rax
mov    (%rax),%edi
lea    0x1c07(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a57(%rip),%rax
mov    (%rax),%edi
lea    0x1c5a(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a42(%rip),%rax
mov    (%rax),%edi
lea    0x1c9c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a2d(%rip),%rax
mov    (%rax),%edi
lea    0x1cf1(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a18(%rip),%rax
mov    (%rax),%edi
lea    0x1d46(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3a03(%rip),%rax
mov    (%rax),%edi
lea    0x1d8f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39ee(%rip),%rax
mov    (%rax),%edi
lea    0x1d86(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39d9(%rip),%rax
mov    (%rax),%edi
lea    0x1d85(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39c4(%rip),%rax
mov    (%rax),%edi
lea    0x1d80(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x39af(%rip),%rax
mov    (%rax),%edi
lea    0x1d8b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x399a(%rip),%rax
mov    (%rax),%edi
lea    0x1d96(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3985(%rip),%rax
mov    (%rax),%edi
lea    0x1d99(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3970(%rip),%rax
mov    (%rax),%edi
lea    0x1da1(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x395b(%rip),%rax
mov    (%rax),%edi
lea    0x1db6(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3946(%rip),%rax
mov    (%rax),%edi
lea    0x1dcf(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3931(%rip),%rax
mov    (%rax),%edi
lea    0x1dff(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x391c(%rip),%rax
mov    (%rax),%edi
lea    0x1e0d(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x3907(%rip),%rax
mov    (%rax),%edi
lea    0x1e28(%rip),%rsi
call   1030 <fprintf@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<display_usage>:
push   %r14
push   %rbx
push   %rax
mov    0x3ec5(%rip),%rbx
mov    (%rbx),%edi
lea    0xedc(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x2271(%rip),%r14
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf1d(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf33(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf45(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf8b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfe7(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1031(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x108a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10e8(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x112f(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x117e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11bc(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11fb(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1238(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1271(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12ae(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12ee(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1332(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x135e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x13a0(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x13e3(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1412(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x140d(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1469(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x14c6(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1525(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1581(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x15e0(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1621(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x167e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x16b1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x170a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1768(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x178a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x17e5(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1833(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x188e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x18e2(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x193e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1999(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x19f1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1a4a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1aa8(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1b06(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1b61(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1bb5(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1c0f(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1c65(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1cbe(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1cc7(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1d22(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1d7b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1dd5(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1e1e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1e7a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1ed6(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f26(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f24(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f2a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f2c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f3e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f50(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f5a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f69(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1f85(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1fa5(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1fdc(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1ff1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x2013(%rip),%rsi
add    $0x8,%rsp
pop    %rbx
pop    %r14
jmp    1030 <fprintf@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [96 x i8] c"Usage: djent [-brRpcCuhds] [-l <n>] [-i <input file list filename>] [filename] [filename2] ...\0A\00"
@.str.1 = [2 x i8] c"\0A\00"
@.str.2 = [36 x i8] c"Compute statistics of random data.\0A\00"
@.str.3 = [42 x i8] c" Author: David Johnston, dj@deadhat.com\0A\00"
@.str.4 = [84 x i8] c" -i <filename> --inputfilelist=<filename> Read list of filenames from <filename>\0A\00"
@.str.5 = [106 x i8] c" -p --parse_filename Extract CID, Process, Voltage and Temperature from filename.\0A\00"
@.str.6 = [88 x i8] c" The values will be included in the output.\0A\00"
@.str.7 = [103 x i8] c" -l <n> --symbol_length=<n> Treat incoming data symbols as bitlength n. Default is 8.\0A\00"
@.str.8 = [108 x i8] c" -b --binary Treat incoming data as binary. Default bit length will be -l 1\0A\00"
@.str.9 = [85 x i8] c" -r --byte_reverse Reverse the bit order in incoming bytes\0A\00"
@.str.10 = [93 x i8] c" -R --word_reverse Reverse the byte order in incoming 4 byte words\0A\00"
@.str.11 = [76 x i8] c" -c --occurrence Print symbol occurrence counts\0A\00"
@.str.12 = [77 x i8] c" -C --longest Print symbol longest run counts\0A\00"
@.str.13 = [75 x i8] c" -w --scc_wrap Treat data as cyclical in SCC\0A\00"
@.str.14 = [71 x i8] c" -n <n> --lagn=<n> Lag gap in SCC. Default=1\0A\00"
@.str.15 = [75 x i8] c" -S <n> --skip=<n> Skip over <n> initial symbols\0A\00"
@.str.16 = [78 x i8] c" -L <n> --substring=<n> Analyse no more that <n> symbols\0A\00"
@.str.17 = [82 x i8] c" -f --fold Fold uppercase letters to lower case\0A\00"
@.str.18 = [58 x i8] c" -t --terse Terse output\0A\00"
@.str.19 = [80 x i8] c" -e --ent_exact Exactly match output format of ent\0A\00"
@.str.20 = [81 x i8] c" -s --suppress_header Suppress the header in terse output\0A\00"
@.str.21 = [61 x i8] c" -h or -u --help Print this text\0A\00"
@.str.22 = [9 x i8] c"\0A Notes\0A\00"
@.str.23 = [106 x i8] c" * By default djent is in hex mode where it reads ascii hex data and converts it to binary to analyze.\0A\00"
@.str.24 = [107 x i8] c" In hex mode, the symbol length defaults to 8, so normal hex files can be treated as a representation\0A\00"
@.str.25 = [109 x i8] c" of bytes. The symbol length can be changed to any value between 1 and 32 bits using the -l <n> option.\0A\00"
@.str.26 = [106 x i8] c" * With the -b option djent switches to binary reads in each byte as binary with a symbol length of 1.\0A\00"
@.str.27 = [109 x i8] c" * To analyze ascii text instead of hex ascii, you need djent to treat each byte as a separate symbol, so\0A\00"
@.str.28 = [79 x i8] c" use binary mode with a symbol length of 8. I.E. djent -b -l 8 <filename>\0A\00"
@.str.29 = [107 x i8] c" * By default djent treats the MSB of each byte as the first. This can be switched so that djent treats\0A\00"
@.str.30 = [65 x i8] c" the LSB as the first bit in each byte using the -r option.\0A\00"
@.str.31 = [103 x i8] c" * Terse output is requested using -t. This outputs in CSV format. The first line is the header. If\0A\00"
@.str.32 = [108 x i8] c" multiple files are provided, there will be one line of CSV output per file in addition to the header.\0A\00"
@.str.33 = [48 x i8] c" The CSV header can be suppressed with -s.\0A\00"
@.str.34 = [105 x i8] c" * To analyze multiple files, just give multiple file names on the command line. To read data in from\0A\00"
@.str.35 = [92 x i8] c" the command line, don't provide a filename and pipe the data in. <datasource> | djent\0A\00"
@.str.36 = [105 x i8] c" * The parse filename option =p picks takes four patterns from the filename to include in the output,\0A\00"
@.str.37 = [98 x i8] c" This is so that it is easy to plot test conditions that are commonly encoded in a filename.\0A\00"
@.str.38 = [106 x i8] c" Fields are delimited by uderscores. The four patters for CID, process, Voltage and Temperature are:\0A\00"
@.str.39 = [105 x i8] c" _CID-<componentID>_ , _PROC-<process info>_, _<x>p<y>V_ and _<x>p<y>C_ . 'p' is the decimal point.\0A\00"
@.str.40 = [102 x i8] c" * To compute the statistics, djent builds a frequency table of the symbols. This can be displayed\0A\00"
@.str.41 = [103 x i8] c" using the -c option. The size of this table is what limits the the maximum symbol size. For each\0A\00"
@.str.42 = [108 x i8] c" of the 2^n symbols, a 64 bit entry in a table is created. So for n=32, that's 32GBytes so the ability\0A\00"
@.str.43 = [108 x i8] c" to handle large symbol sizes is limited by the available memory and the per process allocation limit.\0A\00"
@.str.44 = [105 x i8] c" * The serial correlation coefficient is not wrap around by default, meaning that it does not compare\0A\00"
@.str.45 = [98 x i8] c" the last value in the data with the first. To get wrap around behaviour, use the -w option.\0A\00"
@.str.46 = [104 x i8] c" * The Lag-N correlation coefficient can be computed by using the -n <n> option. This causes the SCC\0A\00"
@.str.47 = [100 x i8] c" computation to compare each Xth symbol with the (X+n)th symbol instead of the (X+1)th symbol.\0A\00"
@.str.48 = [103 x i8] c" If you use wrap around with Lag-N, then the wrap around will reach n bits further into the start\0A\00"
@.str.49 = [23 x i8] c" of the sequence.\0A\00"
@.str.50 = [105 x i8] c" * The byte reverse option -r reverses the order of bits within each byte. The word reverse option -R\0A\00"
@.str.51 = [103 x i8] c" reverses the order of bytes within each 32 bit word, from 3,2,1,0 to 0,1,2,3. Both -R and -r can\0A\00"
@.str.52 = [104 x i8] c" be used together. Using -R with a data that isn't a multiple of 32 bits long will get padded with\0A\00"
@.str.53 = [87 x i8] c" zeros, which may not be what you want. A padding warning will be sent to STDERR.\0A\00"
@.str.54 = [106 x i8] c" * Instead of providing data file names on the command line, djent can be told to read a list of files\0A\00"
@.str.55 = [106 x i8] c" from a text file. The file must have one filename per line. Lines beginning with # will be ignored.\0A\00"
@.str.56 = [94 x i8] c" Use the -i <filename> option to request that djent reads the file list from <filename>.\0A\00"
@.str.57 = [12 x i8] c"\0A Examples\0A\00"
@.str.58 = [20 x i8] c" Print this help\0A\00"
@.str.59 = [16 x i8] c" djent -h\0A\0A\00"
@.str.60 = [32 x i8] c" Analyze hex file from stdin\0A\00"
@.str.61 = [32 x i8] c" cat datafile.hex | djent\0A\0A\00"
@.str.62 = [24 x i8] c" Analyze binary file\0A\00"
@.str.63 = [29 x i8] c" djent -b datafile.bin\0A\0A\00"
@.str.64 = [42 x i8] c" Analyze several files with CSV output\0A\00"
@.str.65 = [46 x i8] c" djent -t data1.hex data2.hex data3.hex\0A\0A\00"
@.str.66 = [69 x i8] c" Analyze ascii symbols - Read in binary and set symbol size to 8.\0A\00"
@.str.67 = [35 x i8] c" djent -b -l 8 textfile.txt\0A\0A\00"
@.str.68 = [48 x i8] c" Analyze binary file with parsable filename.\0A\00"
@.str.69 = [64 x i8] c" djent -b -t -p rawdata_CID-X23_PROC-TTFT_1p2V_25p0C_.bin\0A\00"
define void @display_usage() {
%1 = load i32, i32* @stderr
%2 = call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([96 x i8], [96 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stderr
%4 = call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stderr
%6 = call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0))
%7 = load i32, i32* @stderr
%8 = call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.3, i64 0, i64 0))
%9 = load i32, i32* @stderr
%10 = call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%11 = load i32, i32* @stderr
%12 = call i32 @fprintf(i32 %11, i8* getelementptr inbounds ([84 x i8], [84 x i8]* @.str.4, i64 0, i64 0))
%13 = load i32, i32* @stderr
%14 = call i32 @fprintf(i32 %13, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.5, i64 0, i64 0))
%15 = load i32, i32* @stderr
%16 = call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.6, i64 0, i64 0))
%17 = load i32, i32* @stderr
%18 = call i32 @fprintf(i32 %17, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.7, i64 0, i64 0))
%19 = load i32, i32* @stderr
%20 = call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.8, i64 0, i64 0))
%21 = load i32, i32* @stderr
%22 = call i32 @fprintf(i32 %21, i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.9, i64 0, i64 0))
%23 = load i32, i32* @stderr
%24 = call i32 @fprintf(i32 %23, i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str.10, i64 0, i64 0))
%25 = load i32, i32* @stderr
%26 = call i32 @fprintf(i32 %25, i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.11, i64 0, i64 0))
%27 = load i32, i32* @stderr
%28 = call i32 @fprintf(i32 %27, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.12, i64 0, i64 0))
%29 = load i32, i32* @stderr
%30 = call i32 @fprintf(i32 %29, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.13, i64 0, i64 0))
%31 = load i32, i32* @stderr
%32 = call i32 @fprintf(i32 %31, i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.14, i64 0, i64 0))
%33 = load i32, i32* @stderr
%34 = call i32 @fprintf(i32 %33, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.15, i64 0, i64 0))
%35 = load i32, i32* @stderr
%36 = call i32 @fprintf(i32 %35, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.16, i64 0, i64 0))
%37 = load i32, i32* @stderr
%38 = call i32 @fprintf(i32 %37, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.17, i64 0, i64 0))
%39 = load i32, i32* @stderr
%40 = call i32 @fprintf(i32 %39, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.18, i64 0, i64 0))
%41 = load i32, i32* @stderr
%42 = call i32 @fprintf(i32 %41, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.19, i64 0, i64 0))
%43 = load i32, i32* @stderr
%44 = call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.20, i64 0, i64 0))
%45 = load i32, i32* @stderr
%46 = call i32 @fprintf(i32 %45, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.21, i64 0, i64 0))
%47 = load i32, i32* @stderr
%48 = call i32 @fprintf(i32 %47, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i64 0, i64 0))
%49 = load i32, i32* @stderr
%50 = call i32 @fprintf(i32 %49, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.23, i64 0, i64 0))
%51 = load i32, i32* @stderr
%52 = call i32 @fprintf(i32 %51, i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.24, i64 0, i64 0))
%53 = load i32, i32* @stderr
%54 = call i32 @fprintf(i32 %53, i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.25, i64 0, i64 0))
%55 = load i32, i32* @stderr
%56 = call i32 @fprintf(i32 %55, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.26, i64 0, i64 0))
%57 = load i32, i32* @stderr
%58 = call i32 @fprintf(i32 %57, i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.27, i64 0, i64 0))
%59 = load i32, i32* @stderr
%60 = call i32 @fprintf(i32 %59, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.28, i64 0, i64 0))
%61 = load i32, i32* @stderr
%62 = call i32 @fprintf(i32 %61, i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.29, i64 0, i64 0))
%63 = load i32, i32* @stderr
%64 = call i32 @fprintf(i32 %63, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.30, i64 0, i64 0))
%65 = load i32, i32* @stderr
%66 = call i32 @fprintf(i32 %65, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.31, i64 0, i64 0))
%67 = load i32, i32* @stderr
%68 = call i32 @fprintf(i32 %67, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.32, i64 0, i64 0))
%69 = load i32, i32* @stderr
%70 = call i32 @fprintf(i32 %69, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.33, i64 0, i64 0))
%71 = load i32, i32* @stderr
%72 = call i32 @fprintf(i32 %71, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.34, i64 0, i64 0))
%73 = load i32, i32* @stderr
%74 = call i32 @fprintf(i32 %73, i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.35, i64 0, i64 0))
%75 = load i32, i32* @stderr
%76 = call i32 @fprintf(i32 %75, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.36, i64 0, i64 0))
%77 = load i32, i32* @stderr
%78 = call i32 @fprintf(i32 %77, i8* getelementptr inbounds ([98 x i8], [98 x i8]* @.str.37, i64 0, i64 0))
%79 = load i32, i32* @stderr
%80 = call i32 @fprintf(i32 %79, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.38, i64 0, i64 0))
%81 = load i32, i32* @stderr
%82 = call i32 @fprintf(i32 %81, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.39, i64 0, i64 0))
%83 = load i32, i32* @stderr
%84 = call i32 @fprintf(i32 %83, i8* getelementptr inbounds ([102 x i8], [102 x i8]* @.str.40, i64 0, i64 0))
%85 = load i32, i32* @stderr
%86 = call i32 @fprintf(i32 %85, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.41, i64 0, i64 0))
%87 = load i32, i32* @stderr
%88 = call i32 @fprintf(i32 %87, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.42, i64 0, i64 0))
%89 = load i32, i32* @stderr
%90 = call i32 @fprintf(i32 %89, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.43, i64 0, i64 0))
%91 = load i32, i32* @stderr
%92 = call i32 @fprintf(i32 %91, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.44, i64 0, i64 0))
%93 = load i32, i32* @stderr
%94 = call i32 @fprintf(i32 %93, i8* getelementptr inbounds ([98 x i8], [98 x i8]* @.str.45, i64 0, i64 0))
%95 = load i32, i32* @stderr
%96 = call i32 @fprintf(i32 %95, i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.46, i64 0, i64 0))
%97 = load i32, i32* @stderr
%98 = call i32 @fprintf(i32 %97, i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.47, i64 0, i64 0))
%99 = load i32, i32* @stderr
%100 = call i32 @fprintf(i32 %99, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.48, i64 0, i64 0))
%101 = load i32, i32* @stderr
%102 = call i32 @fprintf(i32 %101, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.49, i64 0, i64 0))
%103 = load i32, i32* @stderr
%104 = call i32 @fprintf(i32 %103, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.50, i64 0, i64 0))
%105 = load i32, i32* @stderr
%106 = call i32 @fprintf(i32 %105, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.51, i64 0, i64 0))
%107 = load i32, i32* @stderr
%108 = call i32 @fprintf(i32 %107, i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.52, i64 0, i64 0))
%109 = load i32, i32* @stderr
%110 = call i32 @fprintf(i32 %109, i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.53, i64 0, i64 0))
%111 = load i32, i32* @stderr
%112 = call i32 @fprintf(i32 %111, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.54, i64 0, i64 0))
%113 = load i32, i32* @stderr
%114 = call i32 @fprintf(i32 %113, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.55, i64 0, i64 0))
%115 = load i32, i32* @stderr
%116 = call i32 @fprintf(i32 %115, i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str.56, i64 0, i64 0))
%117 = load i32, i32* @stderr
%118 = call i32 @fprintf(i32 %117, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.57, i64 0, i64 0))
%119 = load i32, i32* @stderr
%120 = call i32 @fprintf(i32 %119, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.58, i64 0, i64 0))
%121 = load i32, i32* @stderr
%122 = call i32 @fprintf(i32 %121, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.59, i64 0, i64 0))
%123 = load i32, i32* @stderr
%124 = call i32 @fprintf(i32 %123, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.60, i64 0, i64 0))
%125 = load i32, i32* @stderr
%126 = call i32 @fprintf(i32 %125, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.61, i64 0, i64 0))
%127 = load i32, i32* @stderr
%128 = call i32 @fprintf(i32 %127, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.62, i64 0, i64 0))
%129 = load i32, i32* @stderr
%130 = call i32 @fprintf(i32 %129, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.63, i64 0, i64 0))
%131 = load i32, i32* @stderr
%132 = call i32 @fprintf(i32 %131, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.64, i64 0, i64 0))
%133 = load i32, i32* @stderr
%134 = call i32 @fprintf(i32 %133, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.65, i64 0, i64 0))
%135 = load i32, i32* @stderr
%136 = call i32 @fprintf(i32 %135, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.66, i64 0, i64 0))
%137 = load i32, i32* @stderr
%138 = call i32 @fprintf(i32 %137, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.67, i64 0, i64 0))
%139 = load i32, i32* @stderr
%140 = call i32 @fprintf(i32 %139, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.68, i64 0, i64 0))
%141 = load i32, i32* @stderr
%142 = call i32 @fprintf(i32 %141, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.69, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [96 x i8] c"Usage: djent [-brRpcCuhds] [-l <n>] [-i <input file list filename>] [filename] [filename2] ...\0A\00"
@.str.1 = [2 x i8] c"\0A\00"
@.str.2 = [36 x i8] c"Compute statistics of random data.\0A\00"
@.str.3 = [42 x i8] c" Author: David Johnston, dj@deadhat.com\0A\00"
@.str.4 = [84 x i8] c" -i <filename> --inputfilelist=<filename> Read list of filenames from <filename>\0A\00"
@.str.5 = [106 x i8] c" -p --parse_filename Extract CID, Process, Voltage and Temperature from filename.\0A\00"
@.str.6 = [88 x i8] c" The values will be included in the output.\0A\00"
@.str.7 = [103 x i8] c" -l <n> --symbol_length=<n> Treat incoming data symbols as bitlength n. Default is 8.\0A\00"
@.str.8 = [108 x i8] c" -b --binary Treat incoming data as binary. Default bit length will be -l 1\0A\00"
@.str.9 = [85 x i8] c" -r --byte_reverse Reverse the bit order in incoming bytes\0A\00"
@.str.10 = [93 x i8] c" -R --word_reverse Reverse the byte order in incoming 4 byte words\0A\00"
@.str.11 = [76 x i8] c" -c --occurrence Print symbol occurrence counts\0A\00"
@.str.12 = [77 x i8] c" -C --longest Print symbol longest run counts\0A\00"
@.str.13 = [75 x i8] c" -w --scc_wrap Treat data as cyclical in SCC\0A\00"
@.str.14 = [71 x i8] c" -n <n> --lagn=<n> Lag gap in SCC. Default=1\0A\00"
@.str.15 = [75 x i8] c" -S <n> --skip=<n> Skip over <n> initial symbols\0A\00"
@.str.16 = [78 x i8] c" -L <n> --substring=<n> Analyse no more that <n> symbols\0A\00"
@.str.17 = [82 x i8] c" -f --fold Fold uppercase letters to lower case\0A\00"
@.str.18 = [58 x i8] c" -t --terse Terse output\0A\00"
@.str.19 = [80 x i8] c" -e --ent_exact Exactly match output format of ent\0A\00"
@.str.20 = [81 x i8] c" -s --suppress_header Suppress the header in terse output\0A\00"
@.str.21 = [61 x i8] c" -h or -u --help Print this text\0A\00"
@.str.22 = [9 x i8] c"\0A Notes\0A\00"
@.str.23 = [106 x i8] c" * By default djent is in hex mode where it reads ascii hex data and converts it to binary to analyze.\0A\00"
@.str.24 = [107 x i8] c" In hex mode, the symbol length defaults to 8, so normal hex files can be treated as a representation\0A\00"
@.str.25 = [109 x i8] c" of bytes. The symbol length can be changed to any value between 1 and 32 bits using the -l <n> option.\0A\00"
@.str.26 = [106 x i8] c" * With the -b option djent switches to binary reads in each byte as binary with a symbol length of 1.\0A\00"
@.str.27 = [109 x i8] c" * To analyze ascii text instead of hex ascii, you need djent to treat each byte as a separate symbol, so\0A\00"
@.str.28 = [79 x i8] c" use binary mode with a symbol length of 8. I.E. djent -b -l 8 <filename>\0A\00"
@.str.29 = [107 x i8] c" * By default djent treats the MSB of each byte as the first. This can be switched so that djent treats\0A\00"
@.str.30 = [65 x i8] c" the LSB as the first bit in each byte using the -r option.\0A\00"
@.str.31 = [103 x i8] c" * Terse output is requested using -t. This outputs in CSV format. The first line is the header. If\0A\00"
@.str.32 = [108 x i8] c" multiple files are provided, there will be one line of CSV output per file in addition to the header.\0A\00"
@.str.33 = [48 x i8] c" The CSV header can be suppressed with -s.\0A\00"
@.str.34 = [105 x i8] c" * To analyze multiple files, just give multiple file names on the command line. To read data in from\0A\00"
@.str.35 = [92 x i8] c" the command line, don't provide a filename and pipe the data in. <datasource> | djent\0A\00"
@.str.36 = [105 x i8] c" * The parse filename option =p picks takes four patterns from the filename to include in the output,\0A\00"
@.str.37 = [98 x i8] c" This is so that it is easy to plot test conditions that are commonly encoded in a filename.\0A\00"
@.str.38 = [106 x i8] c" Fields are delimited by uderscores. The four patters for CID, process, Voltage and Temperature are:\0A\00"
@.str.39 = [105 x i8] c" _CID-<componentID>_ , _PROC-<process info>_, _<x>p<y>V_ and _<x>p<y>C_ . 'p' is the decimal point.\0A\00"
@.str.40 = [102 x i8] c" * To compute the statistics, djent builds a frequency table of the symbols. This can be displayed\0A\00"
@.str.41 = [103 x i8] c" using the -c option. The size of this table is what limits the the maximum symbol size. For each\0A\00"
@.str.42 = [108 x i8] c" of the 2^n symbols, a 64 bit entry in a table is created. So for n=32, that's 32GBytes so the ability\0A\00"
@.str.43 = [108 x i8] c" to handle large symbol sizes is limited by the available memory and the per process allocation limit.\0A\00"
@.str.44 = [105 x i8] c" * The serial correlation coefficient is not wrap around by default, meaning that it does not compare\0A\00"
@.str.45 = [98 x i8] c" the last value in the data with the first. To get wrap around behaviour, use the -w option.\0A\00"
@.str.46 = [104 x i8] c" * The Lag-N correlation coefficient can be computed by using the -n <n> option. This causes the SCC\0A\00"
@.str.47 = [100 x i8] c" computation to compare each Xth symbol with the (X+n)th symbol instead of the (X+1)th symbol.\0A\00"
@.str.48 = [103 x i8] c" If you use wrap around with Lag-N, then the wrap around will reach n bits further into the start\0A\00"
@.str.49 = [23 x i8] c" of the sequence.\0A\00"
@.str.50 = [105 x i8] c" * The byte reverse option -r reverses the order of bits within each byte. The word reverse option -R\0A\00"
@.str.51 = [103 x i8] c" reverses the order of bytes within each 32 bit word, from 3,2,1,0 to 0,1,2,3. Both -R and -r can\0A\00"
@.str.52 = [104 x i8] c" be used together. Using -R with a data that isn't a multiple of 32 bits long will get padded with\0A\00"
@.str.53 = [87 x i8] c" zeros, which may not be what you want. A padding warning will be sent to STDERR.\0A\00"
@.str.54 = [106 x i8] c" * Instead of providing data file names on the command line, djent can be told to read a list of files\0A\00"
@.str.55 = [106 x i8] c" from a text file. The file must have one filename per line. Lines beginning with # will be ignored.\0A\00"
@.str.56 = [94 x i8] c" Use the -i <filename> option to request that djent reads the file list from <filename>.\0A\00"
@.str.57 = [12 x i8] c"\0A Examples\0A\00"
@.str.58 = [20 x i8] c" Print this help\0A\00"
@.str.59 = [16 x i8] c" djent -h\0A\0A\00"
@.str.60 = [32 x i8] c" Analyze hex file from stdin\0A\00"
@.str.61 = [32 x i8] c" cat datafile.hex | djent\0A\0A\00"
@.str.62 = [24 x i8] c" Analyze binary file\0A\00"
@.str.63 = [29 x i8] c" djent -b datafile.bin\0A\0A\00"
@.str.64 = [42 x i8] c" Analyze several files with CSV output\0A\00"
@.str.65 = [46 x i8] c" djent -t data1.hex data2.hex data3.hex\0A\0A\00"
@.str.66 = [69 x i8] c" Analyze ascii symbols - Read in binary and set symbol size to 8.\0A\00"
@.str.67 = [35 x i8] c" djent -b -l 8 textfile.txt\0A\0A\00"
@.str.68 = [48 x i8] c" Analyze binary file with parsable filename.\0A\00"
@.str.69 = [64 x i8] c" djent -b -t -p rawdata_CID-X23_PROC-TTFT_1p2V_25p0C_.bin\0A\00"
define void @display_usage() {
%1 = load i32, i32* @stderr
%2 = tail call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([96 x i8], [96 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stderr
%4 = tail call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stderr
%6 = tail call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0))
%7 = load i32, i32* @stderr
%8 = tail call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.3, i64 0, i64 0))
%9 = load i32, i32* @stderr
%10 = tail call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%11 = load i32, i32* @stderr
%12 = tail call i32 @fprintf(i32 %11, i8* getelementptr inbounds ([84 x i8], [84 x i8]* @.str.4, i64 0, i64 0))
%13 = load i32, i32* @stderr
%14 = tail call i32 @fprintf(i32 %13, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.5, i64 0, i64 0))
%15 = load i32, i32* @stderr
%16 = tail call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.6, i64 0, i64 0))
%17 = load i32, i32* @stderr
%18 = tail call i32 @fprintf(i32 %17, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.7, i64 0, i64 0))
%19 = load i32, i32* @stderr
%20 = tail call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.8, i64 0, i64 0))
%21 = load i32, i32* @stderr
%22 = tail call i32 @fprintf(i32 %21, i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.9, i64 0, i64 0))
%23 = load i32, i32* @stderr
%24 = tail call i32 @fprintf(i32 %23, i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str.10, i64 0, i64 0))
%25 = load i32, i32* @stderr
%26 = tail call i32 @fprintf(i32 %25, i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.11, i64 0, i64 0))
%27 = load i32, i32* @stderr
%28 = tail call i32 @fprintf(i32 %27, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.12, i64 0, i64 0))
%29 = load i32, i32* @stderr
%30 = tail call i32 @fprintf(i32 %29, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.13, i64 0, i64 0))
%31 = load i32, i32* @stderr
%32 = tail call i32 @fprintf(i32 %31, i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.14, i64 0, i64 0))
%33 = load i32, i32* @stderr
%34 = tail call i32 @fprintf(i32 %33, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.15, i64 0, i64 0))
%35 = load i32, i32* @stderr
%36 = tail call i32 @fprintf(i32 %35, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.16, i64 0, i64 0))
%37 = load i32, i32* @stderr
%38 = tail call i32 @fprintf(i32 %37, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.17, i64 0, i64 0))
%39 = load i32, i32* @stderr
%40 = tail call i32 @fprintf(i32 %39, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.18, i64 0, i64 0))
%41 = load i32, i32* @stderr
%42 = tail call i32 @fprintf(i32 %41, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.19, i64 0, i64 0))
%43 = load i32, i32* @stderr
%44 = tail call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.20, i64 0, i64 0))
%45 = load i32, i32* @stderr
%46 = tail call i32 @fprintf(i32 %45, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.21, i64 0, i64 0))
%47 = load i32, i32* @stderr
%48 = tail call i32 @fprintf(i32 %47, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i64 0, i64 0))
%49 = load i32, i32* @stderr
%50 = tail call i32 @fprintf(i32 %49, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.23, i64 0, i64 0))
%51 = load i32, i32* @stderr
%52 = tail call i32 @fprintf(i32 %51, i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.24, i64 0, i64 0))
%53 = load i32, i32* @stderr
%54 = tail call i32 @fprintf(i32 %53, i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.25, i64 0, i64 0))
%55 = load i32, i32* @stderr
%56 = tail call i32 @fprintf(i32 %55, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.26, i64 0, i64 0))
%57 = load i32, i32* @stderr
%58 = tail call i32 @fprintf(i32 %57, i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.27, i64 0, i64 0))
%59 = load i32, i32* @stderr
%60 = tail call i32 @fprintf(i32 %59, i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.28, i64 0, i64 0))
%61 = load i32, i32* @stderr
%62 = tail call i32 @fprintf(i32 %61, i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.29, i64 0, i64 0))
%63 = load i32, i32* @stderr
%64 = tail call i32 @fprintf(i32 %63, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.30, i64 0, i64 0))
%65 = load i32, i32* @stderr
%66 = tail call i32 @fprintf(i32 %65, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.31, i64 0, i64 0))
%67 = load i32, i32* @stderr
%68 = tail call i32 @fprintf(i32 %67, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.32, i64 0, i64 0))
%69 = load i32, i32* @stderr
%70 = tail call i32 @fprintf(i32 %69, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.33, i64 0, i64 0))
%71 = load i32, i32* @stderr
%72 = tail call i32 @fprintf(i32 %71, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.34, i64 0, i64 0))
%73 = load i32, i32* @stderr
%74 = tail call i32 @fprintf(i32 %73, i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.35, i64 0, i64 0))
%75 = load i32, i32* @stderr
%76 = tail call i32 @fprintf(i32 %75, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.36, i64 0, i64 0))
%77 = load i32, i32* @stderr
%78 = tail call i32 @fprintf(i32 %77, i8* getelementptr inbounds ([98 x i8], [98 x i8]* @.str.37, i64 0, i64 0))
%79 = load i32, i32* @stderr
%80 = tail call i32 @fprintf(i32 %79, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.38, i64 0, i64 0))
%81 = load i32, i32* @stderr
%82 = tail call i32 @fprintf(i32 %81, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.39, i64 0, i64 0))
%83 = load i32, i32* @stderr
%84 = tail call i32 @fprintf(i32 %83, i8* getelementptr inbounds ([102 x i8], [102 x i8]* @.str.40, i64 0, i64 0))
%85 = load i32, i32* @stderr
%86 = tail call i32 @fprintf(i32 %85, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.41, i64 0, i64 0))
%87 = load i32, i32* @stderr
%88 = tail call i32 @fprintf(i32 %87, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.42, i64 0, i64 0))
%89 = load i32, i32* @stderr
%90 = tail call i32 @fprintf(i32 %89, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.43, i64 0, i64 0))
%91 = load i32, i32* @stderr
%92 = tail call i32 @fprintf(i32 %91, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.44, i64 0, i64 0))
%93 = load i32, i32* @stderr
%94 = tail call i32 @fprintf(i32 %93, i8* getelementptr inbounds ([98 x i8], [98 x i8]* @.str.45, i64 0, i64 0))
%95 = load i32, i32* @stderr
%96 = tail call i32 @fprintf(i32 %95, i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.46, i64 0, i64 0))
%97 = load i32, i32* @stderr
%98 = tail call i32 @fprintf(i32 %97, i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.47, i64 0, i64 0))
%99 = load i32, i32* @stderr
%100 = tail call i32 @fprintf(i32 %99, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.48, i64 0, i64 0))
%101 = load i32, i32* @stderr
%102 = tail call i32 @fprintf(i32 %101, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.49, i64 0, i64 0))
%103 = load i32, i32* @stderr
%104 = tail call i32 @fprintf(i32 %103, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.50, i64 0, i64 0))
%105 = load i32, i32* @stderr
%106 = tail call i32 @fprintf(i32 %105, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.51, i64 0, i64 0))
%107 = load i32, i32* @stderr
%108 = tail call i32 @fprintf(i32 %107, i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.52, i64 0, i64 0))
%109 = load i32, i32* @stderr
%110 = tail call i32 @fprintf(i32 %109, i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.53, i64 0, i64 0))
%111 = load i32, i32* @stderr
%112 = tail call i32 @fprintf(i32 %111, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.54, i64 0, i64 0))
%113 = load i32, i32* @stderr
%114 = tail call i32 @fprintf(i32 %113, i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.55, i64 0, i64 0))
%115 = load i32, i32* @stderr
%116 = tail call i32 @fprintf(i32 %115, i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str.56, i64 0, i64 0))
%117 = load i32, i32* @stderr
%118 = tail call i32 @fprintf(i32 %117, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.57, i64 0, i64 0))
%119 = load i32, i32* @stderr
%120 = tail call i32 @fprintf(i32 %119, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.58, i64 0, i64 0))
%121 = load i32, i32* @stderr
%122 = tail call i32 @fprintf(i32 %121, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.59, i64 0, i64 0))
%123 = load i32, i32* @stderr
%124 = tail call i32 @fprintf(i32 %123, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.60, i64 0, i64 0))
%125 = load i32, i32* @stderr
%126 = tail call i32 @fprintf(i32 %125, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.61, i64 0, i64 0))
%127 = load i32, i32* @stderr
%128 = tail call i32 @fprintf(i32 %127, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.62, i64 0, i64 0))
%129 = load i32, i32* @stderr
%130 = tail call i32 @fprintf(i32 %129, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.63, i64 0, i64 0))
%131 = load i32, i32* @stderr
%132 = tail call i32 @fprintf(i32 %131, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.64, i64 0, i64 0))
%133 = load i32, i32* @stderr
%134 = tail call i32 @fprintf(i32 %133, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.65, i64 0, i64 0))
%135 = load i32, i32* @stderr
%136 = tail call i32 @fprintf(i32 %135, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.66, i64 0, i64 0))
%137 = load i32, i32* @stderr
%138 = tail call i32 @fprintf(i32 %137, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.67, i64 0, i64 0))
%139 = load i32, i32* @stderr
%140 = tail call i32 @fprintf(i32 %139, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.68, i64 0, i64 0))
%141 = load i32, i32* @stderr
%142 = tail call i32 @fprintf(i32 %141, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.69, i64 0, i64 0))
ret void
}