;
;    Settings for checksum and simple checksum..
;
;    For help, and an in-depth look at some of the trickier settings, see..
;
;        https://corz.org/windows/software/checksum/checksum-prefs.php
;
;    Adding the "o" switch to the command-line, or holding down the SHIFT key
;    at launch brings up the one-shot options, where you can change many of
;    these settings on-the-fly for a particular job.
;
;    If you want the options to *always* appear on a right-click, you can alter
;    the switches in your explorer registry command. If that sounds daunting,
;    you can edit checksum's setup.ini file, which has comments and such. Then
;    install checksum again (uninstall the old one first, so the new commands
;    get picked up - your settings will be remembered fine). Tada! New commands.
;
;    If you want something set permanently, set it here in checksum.ini.
;
;    Ini settings are usually either an integer (number), a boolean (aka. "bool")
;    which is true or false, or a string of some kind (i.e. a name or file path).
;
;    Later settings override earlier settings, where applicable. Command-line
;    switches override everything. Where a setting has a command-line switch, and
;    is enabled, it can be disabled by prepending the switch with a "-" (minus),
;    symbol, e.g. if the Progress ToolTip is enabled, you can temporarily disable
;    it with "-t" (no quotes).
;
;    Lines beginning ";", like the line you are reading right now, are ignored by
;    checksum. i.e. "the comments".
;
;    Note: this ini file will be automatically upgraded by future versions of
;    checksum, to ensure you have all the latest preferences and features. Your
;    current settings will remain intact, but any notes you might make here will
;    be archived to "<date> checksum.ini", created during the upgrade process.
;
;    Also note: if you mess up some setting, and want to get back the defaults,
;    simply rename or move this file, and run checksum again; its default ini
;    will be re-placed.
;

[checksum]
;
; version number
;
; This is used to keep this ini file up-to-date with all the latest preferences
; and features (whilst keeping your old settings intact, of course)..
;
version=

;
; Usability..
;

;
; Text Editor                       [string/path]  [default: editor=notepad.exe]
;
; We start with this setting - in case you are in Notepad right now,
; and can barely tell the comments and settings apart!
;
; Enter the path to your preferred text editor..
; This is invoked if you select the "edit preferences" menu option.
;
;editor=C:\Program Files\text ed\editplus\editplus.exe
editor=notepad.exe


;
; Pause On Completion            [integer: 1/1000 second]  [default: pause=1000]
;
; command-line switch: n
;
; Normally, if you have the ToolTip enabled, checksum will pause at the end
; of an operation, so you can see the final result. You could have the dialog
; time out very quickly (dialog_timeout, below), and yet keep the ToolTip
; visible. You can change the length of that pause here, in milliseconds.
; The default is 1000 (one second). To disable the pause, set this to 0.
;
pause=1000


;
; "Long Operations"         [integer: 1/100 second]  [default: long_operation=0]
;
; Normally, at the end of any operation, checksum throws up a dialog (usually
; "SUCCESS!" or "ERRORS!" for verification; "All Done!" for hash creation).
; You may prefer to only be notified after "long operations". Enter the
; length of time (in seconds) that you consider to be a "long operation".
;
long_operation=0
;
; Remember, if there were any errors, you will always be notified somehow,
; regardless of what you've set for long_operation (unless running "quiet").
;
; NOTE:    if you are highly-strung, the 'long_operation' setting is accurate to
;        a 100/th of a second, so feel free to use 0.27, or whatever. ;o)
;
; If you have the progress tip enabled, you can see the finish time there, too.


;
; Human-Readable Times?              [bool(ean)]  [default: readable_times=true]
;
; checksum can display its completion times in either seconds, or a more human-
; readable h/m/s format. If you prefer everything in seconds, set this to false.
;
readable_times=true


;
; Dialog time-outs               [integer: seconds]  [default: dialog_timeout=0]
;
; You can set how long you want any dialogs to stay open for, in seconds.
; If you set this to 0 (the default) dialogs won't time-out.
;
dialog_timeout=0



; Hashing..
;

;
; Algorithm..                        [string: md5/sha1]  [default: algorithm=md5]
;
; command-line switch: s    (use sha1)
; command-line switch: 2    (use BLAKE2)
;
; Which algorithm to use when creating hashes?
; Choices are currently "md5", "sha1" or "blake2" (no quotes).
;
algorithm=md5
;


; UPPERCASE hashes                            [bool]  [default: uppercase=false]
;
; command-line switch: u
;
; Hashes are usually lowercase (for the hex alphas; i.e. "abcdef"),
; but you may prefer UPPERCASE..
;
uppercase=false
;


;
; Output Directory                          [string]  [default: out_dir=<blank>]
;
; If you wish, you can specify a directory where checksum will output its
; hash files. Use this with caution; especially when recursively hashing a
; folder with duplicate file/directory names within that structure. In other
; words, don't enable this unless you know exactly WHY you are doing it.
;
out_dir=
;
; NOTE: You can use @tokens in this setting. There is also a new @parent token,
; especially created for the out_dir setting. You can also specify @parent+1,
; @parent+2 and so on, to get strings of "higher-up" directories. See the
; checksum version.nfo (aka. "itstory") for more details.


;
; Default file mask                        [string]  [default: default_mask=*.*]
;
; You can set this to something other than *.*, if required.
; This is usually best left at *.*, using the one-shot options to control
; your file masks on a per-job basis. See also the [file masks] section, below.
;
default_mask=*.*


;
; Unified Hash Extension    [bool]  [default: unified_extension=true]
;
; Rather than create .md5 files for MD5 hashes, and .sha1 files for SHA1
; hashes checksum can use a unified ".hash" extension for both type of
; hash. This is the way forward for hash files, methinks..
;
; checksum, uniquely (syat) will verify both kinds of hashes, even mixed
; up in the same file, so the file extension itself, is irrelevant when
; determining the format of the hashes contained within - checksum
; interrogates potential hash files on a line-by-line basis. Also, in
; the future, there will likely be many more hash formats in use so it
; makes sense to stop the senseless creation of extraneous file
; extensions in its tracks! This is now on by default. If you *need* to
; work with .md5 and .sha1 files rather than .hash files, disable it here.
;
unified_extension=true
;
; NOTE: if the unified extension is enabled, checksum will merge existing
; hash files into your .hash file, so you don't end up with both, but only
; files of the algorithm you are currently using, so if you are using the
; MD5 algorithm, checksum will merge only .md5 files in the path, not .sha1
; files.



;
; Custom BLAKE2 Extension.                 [string] [default: blake_name=blake2]
;
; If you are NOT using the unified hash extension, you might prefer "b2" or
; "blake2s" or something else for your BLAKE2 hashes. Simply set this preference
; to whatever you desire..
;
blake_name=blake2



;
; Always Synchronize                      [boolean] [default: always_sync=false]
;
; command-line switch: y
;
; When checksum is creating folder and root hashes, and discovers hashes
; have already been created in the location, it will pop-up a dialog asking
; if you wish to 1) Overwrite the existing hashes, 2) leave the existing
; hashes as they are, or 3) synchronize the hashes.
;
; When synchronizing, checksum will scan the existing hash file(s), and
; only add hashes for files that have not already been hashed. If you
; want checksum to *always* do this, without having to ask you first, set
; always_sync to true.
;
always_sync=false



;
; TimeStamp    Entries                           [boolean]  [do_timestamp=false]
;
; checksum can add a timestamp (comment) between synchronised operations so that
; each has its own "section". This makes it easy to see/parse which files were
; added to the .hash file.
;
do_timestamp=false



;
; Add file extensions?                  [bool]  [default: file_extensions=false]
;
; command-line switch: e
;
; This is for creation of individual per-file checksums only. For example,
; if you create a checksum of the file "foo.avi", the checksum will be named
; either "foo.hash or "foo.avi.hash, the former being the default (false).
;
; Setting this to false, as well as being more elegant, enables checksum to
; store hashes for "foo.txt" and "foo.nfo", (if such files exist next to
; "foo.avi") all inside "foo.hash", which is neat.
;
file_extensions=false
;
; NOTE: if checksum encounters existing checksum files *not* using your
; current file_extensions setting, it will rename them to match, so in our
; example, if "foo.avi.md5" existed, it would be renamed to "foo.md5", and
; any other foo.files added to that single checksum file.
;

;
; Individual hashes..    [bool]               [default: individual_hashes=false]
;
; command-line switch: i
;
; Instruct checksum to *always* create individual hash files, even when working
; with folders. This is the same as passing "i" in your switches. Most useful
; when combined with file mask groups, e.g. crim(movies). Most people will want
; to leave this set to false.
;
individual_hashes=false
;
; NOTE: if individual_hashes is set to true, you can use "-i" on the command-
; line, to disable it temporarily; and checksum will revert to using regular
; folder hash files when hashing folders.
;
; NOTE: You can set this in the one-shot options.


;
; Master Line Feed setting.           [string (token)] [default: line_feed=CRLF]
;
; This setting defines the type of Line Feed character to use in ALL generated
; files; logs, and music playlists, as well as the checksum files themselves.
; Choose from 'CRLF' (no quotes), the regular Windows Line Break character.
; 'LF', which is a UNIX Line Feed character, and 'CR', which is for Macs.
;
line_feed=CRLF
;
; NOTE: Unless you are creating checksum files *specifically* for use on a
; *specific* platform with a *specific* non-compliant utility, the default
; line_feed is probably just fine. Most *nix tools won't mind CRLF, and many
; Windows applications will insist on it. checksum doesn't mind which you use.
;
; ALSO NOTE: The HTML log template uses the default CRLF line breaks. If you
; set line_feed to LF or CR, your log will contain inconsistent line breaks. If
; you mind about this (your browser won't) then use your own HTML template
; (with the same line breaks you set here). For more info, see the checksum faq
; page..
;
; https://corz.org/windows/software/checksum/faq.php


;
; Ignore..
;
; extensions..         [strings - comma delimited list of dotless file extensions]
;
; Don't create checksums for the following file types. Enter the file type
; extensions (without the dot), as many as you need, separated by commas..
;
ignore_types=md5,sha1,blake2,hash,sfv,crc,lnk,url,m3u,m3u8,pls,log


;
; named files..                   [strings - comma delimited list of file names]
;
; Don't create checksums for the following specific files..
; Specify full names, as many as you need, separated by commas (no wildcards).
;
ignore_files=desktop.ini,folder.jpg,.desktop,.directory,thumbs.db,md5sums,md5sum.txt,.DS_Store,._.DS_Store,pagefile.sys,hiberfil.sys


;
; Folders..   [strings - comma delimited list of folder names][default: <blank>]
;
; Don't create checksums for files inside the following specific folders..
; Specify folder names, as many as you need, separated by commas (no wildcards)
; checksum can work a bit faster if you leave this blank, and most people
; won't need to enabled this.
;
;ignore_folders=RECYCLER,$Recycle.Bin,System Volume Information
ignore_folders=


;
; UNIX hash files        [strings]  [default: unix_hashfiles=md5sums,md5sum.txt]
;
; checksum can also recognize Linux/UNIX/Solaris/etc. checksum formats, even with
; *nix paths. What files would you like checksum to consider as *nix checksum files?
; Multiple entries, and wilcards (*) are allowed, separate entries with commas..
;
unix_hashfiles=md5sums,md5sum.txt
;
; with the above set, you can simply right-click, for example, a Linux distro CD
; and verify the whole thing in one go. Handy. You can safely leave this blank.

; NOTE: you can force checksum to consider ANY file as a checksum file by either
; adding a "v" switch to your command-line, or holding down the <Ctrl> key during
; launch (or when you drag&drop onto checksum with <Ctrl> key held down, you
; will see "+" overlay apprear on the dropped file).


;
; Absolute Paths                         [bool]  [default: absolute_paths=false]
;
; command-line switch: k
;
; When creating a one-file, "root" checksum file, should we use relative or
; absolute paths? A relative path might look like this.. "innerdir\some.zip"
; and has the advantage of continuing to work, wherever you move the disk/folder
; to. If you are ABSOLUTELY sure that this data isn't going to move, you can set
; this to true, and checksum will record the entire absolute path, e.g..
;
; b4b2e666eb17099b1fd10d8e38f56f29 *D:\backups\path\to\innerdir\some.zip
;
absolute_paths=false
;
; You can move this kind of .hash file around; the hashes will always point
; to the same place. This can be handy where you want to keep tabs on a file,
; ensure no one has altered it, but not leave the checksum next to the file.


;
; One-File "root" hashes..                     [bool]  [default: one_hash=false]
;
; command-line switch: 1
;
; Always create a single all-in-one hash files in the root folder checked?
;
one_hash=false
;
; NOTE: this is also the kind of checksum file you get if you attempt to create
; hashes on read-only media (with the default fallback strategy - see below).
; ALSO NOTE: Root hashing automatically enables recursion.


;
; *nix paths                                  [bool]  [default: nix_paths=false]
;
; UNIX roots paths in one-file checksums..
;
; By default, checksum won't add the root, i.e. "./" to the front of the path
; when creating one-file root checksums - if you share checksum files with
; users of certain other windows hashing applications, this may cause them to
; break, but you have the option to enable this, here, if you wish..
nix_paths=false
;
; NOTE: this setting also affects how paths are stored inside music playlist
; files - most players don't mind either way, though.


; Hide checksum files                    [bool]  [default: hide_checksums=false]
;
; command-line switch: h
;
; If you don't want to see the .hash/.md5/.sha1 files in your file system, you
; can instruct checksum to hide them for you. checksum doesn't mind if they
; are hidden or not when it's verifying them, so it's completely up to you..
;
hide_checksums=false


;
; file encoding..
;

;
; UTF-8 encoding                             [bool]  [default: utf8_hashes=true]
;
; I expect other Windows utilities will catch-up, but in the meantime, if
; you need to share hash files with users of ANSI-bound utilities, you
; can disable utf-8 here..
;
utf8_hashes=true
;
; NOTE: checksum-generated logs and music playlists are always utf-8 encoded.



;
; Show UNC-style paths                    [bool]  [default: show_unc_paths=false]
;
; checksum works with "UNC-style" file paths up to 32,767 characters in length.
; These long paths begin with "\\?\" or "\\?\UNC\" (for unmapped network
; volumes). checksum will usually hide these prefixes from you (in logs,
; tooltips, etc.) but if you prefer, you can have them showing all over.
;
show_unc_paths=false


;
; Always store UNC-style paths..        [bool]  [default: always_store_unc=true]
;
; By default, checksum will always store the UNC-style path if you choose to
; record absolute paths. If you prefer, you can have checksum only record the
; UNC-style path if it absolutely required (i.e. the path is longer than the
; Windows API MAX_PATH limit of 259 actual characters).
;
always_store_unc=true



; ToolTip Progress Windoid..
;

; Enable Progress ToolTip?                  [bool]  [default: progress_tip=true]
;
; command-line switch: t
;
; Enable "ToolTip" style progress windoid? You can click and drag it around;
; it will snap to the edges of the desktop (see below), and shouldn't go
; totally off-screen, no matter what you do.
;
progress_tip=true
;
; NOTE: If you disable the progress tip, you also disable tray progress tips
;        (during verification, recent failues are shown there - handy)
;

; ToolTip Font                      [string]  [default: tip_font=Lucida Console]
;
; You can also set the font for the ToolTip (no quotes required)..
;
tip_font=Lucida Console
;
; NOTE: it's best to use a monospaced font, like Courier New, Lucida
; Console, Consolas, monaco, ProFontWindows, etc. Variable width fonts
; will can leave a visually unappealing large gap after the text.
; However; see "tip_stretch", below, for how to tweak this to match
; your favourite font.

; Font size..                              [integer]  [default: tip_font_size=8]
;
; Somewhere between 6 and 12 works well
;
tip_font_size=8

; Snapping distance..                          [integer]  [default: tip_snap=16]
;
; If the Tip is dragged less than *this* many pixels from the top,
; bottom, or left-hand edge of your desktop, it will snap to that edge.
;
; Set this to zero to disable snapping altogether. Large values are fun.
;
tip_snap=16

;
; ToolTip Colors..                [hex]              [default: tip_color=ffffff]
;                                               [default: tip_text_color=000000]
;                                                   [default: warn_color=ff0000]
;
; Use standard six-digit RGB hex values.
;
; Here's a cool way to pick colors..
; https://corz.org/windows/software/color-pickin-chooser/
;
tip_color=ffffff
;
tip_text_color=000000
;

; On errors, the progress tip flashes red (by default: warn_color=ff0000).
; You can change that color here..
;
warn_color=ff0000
;
; NOTE: while flashing the warning color, the progress tip will use your
; tip_color as the color of the warning text (background color; generally
; the inverse of text color). By default, then, warnings are white text
; on a red background.


; And finally, the stretch value.  ... The what?!?
;
; Tip Stretch Value                        [integer]  [delault: tip_stretch=100]
;
; Because of the multifarious nature of fonts, it's almost guesswork to
; stretch a window to *exacitaly* fit the size of the text it contains.
; However, it is possible to estimate it fairly closely, unless you
; use proportional fonts, in which case, who knows! However, if you
; are using some font that falls outside what checksum considers
; "normal", and either; text is being chopped off the end; or there is
; way too much space for your comfort; you can tweak this magic value,
; here, and stretch the window in or out. The default setting is 100 (%)
; Use any value from around 50 to 200. Use smaller values for
; proportional fonts, like Tahoma is.
;
tip_stretch=100
;
; Consolas 8pt @ 75% is quite nice. Tahoma 8 around 72%, and so on.
; Of course, the default of Lucida Console @ 100% is also rather neat.

;
; Note for ToolTip lovers..
;
; It should be noted that, although cool, there is a performance penalty for
; running with the tooltip enabled. Sure, it's a not a huge amount, but still if
; you regularly checksum thousands of very small files, you may want to consider
; disabling it, or at least testing it. Remember, you can right-click the
; tooltip to disable it, and do other stuff, during any checksum operation. Also
; left-clicking the tray icon will toggle the tooltip. If you mostly hash large
; files, or don't care about breakneck speeds, it's not really an issue.


;
; Audio alerts                               [bool]  [default: beep_alerts=true]
;
; command-line switch: b
;
; When checksum discovers a hash failure, it can optionally emit a
; small beep from your peecee speaker. It also beeps on completion.
;
beep_alerts=true

; Beep Frequency                             [integer]  [default: beep_freq=500]
;
; You can specify the beep frequency, in Hz, from 37 - 19999,
; e.g. beep_freq=1000
;
beep_freq=500

; At the end of an operation, checksum will emit a final, shorter double-beep.
;
; If there were any errors, you hear the fail (alert) beep. If everything was
; 100%, checksum will emit the double-beep at exactly double the above
; frequency, i.e. a higher pitch.

; Note: If you have a LOT of errors, all this beeping will slow things down
; slightly, but it's generally useful enough to leave enabled all the time.


;
; WAV audio alerts                 [string{file path}]  [default:beep_*=<blank>]
;
; You can also use WAV files for your audio alerts, if you wish.
; beep_fail sounds on any verification failures. At the end, if there were
; were failures beep_fail sounds again, if all is well, beep_success plays.
;
; Enter the full path to the WAV files to use for the success and failure.
; If these are left blank (the default), checksum will use your PC speaker,
; as outlined above. If you enter an incorrect path, again, checksum will
; revert to using PC speaker beeps.
;
beep_success=
beep_fail=
;
; NOTE: audio alerts have *nothing* to do with the next preference..


; Quiet Operation                       [bool]  [default: quiet_operation=false]
;
; command-line switch: q/q+/qy
;
; If you are scripting checksum, or creating some special wrapper/GUI, then
; you may want to disable all dialogs..
;
; note: if checksum encounters existing checksums during creation, it will
; continue as if you had clicked "No to All", in the dialog, so no existing
; checksum files will be altered in any way. To overwrite existing checksums,
; use 'q+' on the command-line. To get synchronisation, add the "y" switch,
; anywhere. You can set quiet operation permanently, here, if desired..
;
quiet_operation=false


;
;    Logging (for verification)..
;
;
; Log to a file                             [bool]  [default: log_to_file=false]
;
; command-line switch: f
;
; By default, this is left at false. You always have the option override
; this, should you ever need it. Remember, unless running in "quiet" mode,
; if there are any checksum verification failures, you will get a dialog,
; with the option to log them to a file. If you want to always log errors
; to a file, set this to true.
;
log_to_file=false
;

; Log everything!                        [bool]  [default: log_everything=false]
;
; command-line switch: l
;
; Log both failures AND successes. Note: can create potentially HUGE logs!
; which would use lots of memory (currently).
;
log_everything=false
;
; NOTE: Setting this automatically sets the "f" switch (log to file)


;
; Append log files to old logs?              [bool]  [default: append_logs=true]
;
; Set this to false to *always* create a new log file
; Set it to true, and open up lots of possibilities..
;
; If you set this to true, and use your log file name @tokens
; creatively, you can get automatic log rotation on a daily/monthly/etc basic
; you could even have logs for each particular checked folder, automatically
; rotating every month, or whatever. @tokens + append = free energy!
; Like I said, get creative!
;
append_logs=true

;
; Name of the log folder      [string/path]  [default: log_folder=@userdir\logs]
;
; Leave blank (the default) to drop logs in the top-most verified folder
; you can also specify a relative path, by simply using a string. eg. if
; you want the logs to go inside a folder called "checksum logs", use:
;log_folder=checksum logs
; and this folder will be created inside the top-most folder checked.
;
; There is also a special token which you can use; @checksumdir
; which is automagically transformed into checksum's own folder (where
; checksum.exe is) - handy for running in portable mode. If you wanted
; to use a folder called "logs" inside there, do: log_folder=@checksumdir\logs
;
; There is also a token for @userdir, which will place logs inside your user
; checksum data folder (where this ini lives, by default). In fact, this is
; the default setting, in a folder called "logs"..
;
log_folder=@userdir\logs

;
; Log Name   [string] [default: log_name=[@year-@mon-@mday] checksums for @item]
;
; As well as typing in a regular file name, such as "checksum.log", you
; can use cool @tokens to insert the current..
;
;    @sec            seconds value. from 00 to 59
;    @min            minutes value. from 00 to 59
;    @hour           hours value, in 24-hour format.  from 00 to 23
;    @mday           numeric day of month. from 01 to 31
;    @mon            numeric month. from 01 to 12
;    @year           four-digit year
;    @wday           numeric day of week. from 1 to 7 which corresponds to Sunday through Saturday.
;    @yday           numeric day of year. from 1 to 366 (or 365 if not a leap year)
;
;    There is also a special log_name token: @item which will be transformed into the name of the
;    file or folder being checked, and @status, which transforms into the success/failure status
;
; You can mix these up with regular strings, like so..
;
log_name=[@year-@mon-@mday] checksums for @item
;
; There's no need to add the extension, it will be ".log" or ".html",
; depending on whatever log_format you have specified (below).
;
; The above default is daily log rotation, sorted by name of @item checked
;
; Here's automatic (all-in-one) daily rotation..
;
;    log_name=[@year-@mon-@mday] checksums
;
; and so on.
;

; The @status strings can also be individually configured.. [strings]
;
status_fail=ERRORS
status_success=100% AOK
;

;
; For example; with this log_name setting..
;
;    log_name=[@year-@mon-@mday @ @hour.@min.@sec] checksums for @item [@status!]
;
; The final log name might be..
;
; [2007-11-11 @ 16.43.50] checksums for golden boy [100% AOK!].log
;
;

;
; Log format                     [string: text/html]  [default: log_format=html]
;
; checksum can output logs in plain text, or spiffy XHTML. In XHTML logs,
; all styles and positions are controlled by css, so you can customize your
; log output to your own exacting specifications, even the look of old logs,
; or all your logs, with one simple edit. Oh joy of CSS!
;
; The plain text logs are actually pretty neat, too. Your call..
;
log_format=html

;
; Paths In Titles                        [bool]  [default: path_in_titles=false]
;
; The title of each main section is the date and time of the operation.
; You can also prepend the (base)name of the path checked, e.g..
;
;    [2006] Rodrigo y Gabriela @ 2007-11-21 14:14:00
;
; If you tend to log checksums for a single path in one file, where only the
; date & time is really meaningful, it's unlikely you would want this. It
; does make your logs look rather uneven, anyway.
;
path_in_titles=false

;
; Full Paths In Hash File Titles..       [bool]  [default: hashfile_paths=false]
;
; the title of each checksum file checked is the name of the checksum file itself,
; either with or without the full path. If you want the full path in your logs,
; set this to true..
;
hashfile_paths=false

;
; Truncate Full Paths at..                  [integer]  [default: truncate_at=72]
;
; It's quite possible that with hashfile_paths set to true, the title could get
; *very* large, so checksum will thoughtfully truncate it to however long you
; specify here. note: the truncation occurs in the middle, so you can always see
; the name of the actual checksum file. The default is 72 (characters).
;
truncate_at=72

;
; Display Verification Times?             [bool]  [default: display_times=false]
;
; You can optionally display the time taken to verify each checksum file,
; right after the name of the checksum file itself, something like..
; isolinux.md5   [checked in 0.043s]
;
display_times=false

;
; Display Total Times                       [bool]  [default: total_times=false]
;
; A bit ugly, but you might want this information - the total time taken
; can be tagged onto the main checksum titles (date/time checked)
; something like..    "2007-11-21 11:10:58  [total time: 7.972s]"
;
; NOTE: This is a running tally of all the individual times taken to hash
; each file, and so will probably be *slightly* less than the total time
; displayed in the final ToolTip, which includes times for *all* operations,
; file handling, etc.
;
; ALSO NOTE: For this to work, "display_times" (above) must also be set to true.
;
total_times=false


;
; Open Log Folder?                       [bool]  [default: open_log_folder=true]
;
; command-line switch: g
;
; If a log was created (there were errors, or you enabled "log_everything"),
; checksum will automatically open the log folder for you at the end of the
; verify operation, or not..
;
open_log_folder=true

;
; Compress logs                            [bool]  [default: compress_logs=true]
;
; checksum will attempt to compress your logs after creating them, using
; Windows' built-in compress.exe. This can potentially save you a *lot*
; of space. If you would prefere checksum not to do this, set this to false.
;
compress_logs=true
;
; checksum will compress the entire log folder (so long as you aren't logging
; to your checksum program folder) as well as individual uncompressed logs, so
; any files you add to that folder, will also be automatically compressed.
; log compression can save you 80%+ disk space. plain text compresses well.


;
; CSS (style sheets)..
;
; For the why and how of CSS in checksum's logs, see here..
;
; https://corz.org/windows/software/checksum/checksum-prefs.php#css_logic
;

; corz.org fall-back styles..            [bool]  [default: fallback_styles=true]
;
; This is the first of the imported styles (1 of 3)
;
; Insert a css @import for default live fall-back styles.
; This is hosted on corz.org, so you can always get to it (theoretically!).
;
fallback_styles=true
;
; You can also enter the full path to a fall-back style, if you wish, e.g..
;
; fallback_styles=https://corz.org/windows/software/checksum/files/olive.css
;

; Master styles..                          [bool]  [default: master_styles=true]
;
; This is the second of the imported styles (2 of 3)
;
; The master styles - generally set to true, where checksum will insert the
; location of the master checksum.css (usually next to checksum.exe). But if you
; like, you can override that here. Remember, if you are using a local
; filesystem location it will need to use "file:///", something like..
;
;    master_styles=tfile:///C:/Path/to my/styles/checksum.css
;
master_styles=true
;
; 3 of 3 is the checksum.css in your log folder, if such a file exists.


; Embed styles in logs                     [bool]  [default: embed_styles=false]
;
; If you like, you can embed your styles inside the log file itself. Though you
; lose the many advantages of css @import, you do get completely self-contained
; logs (style-wise).
;
; Your master checksum.css (next to checksum.exe) will be used as the template,
; so new logs will contain whatever styles you edit into there.
;
embed_styles=false
;
; Setting this to true, disables the third and final css @import. If you also
; set fallback_styles to false, and master_styles to false, your log files will
; contain *only* embedded styles from your template, which may be what you want.
;


; Check Dates and Times                      [bool]  [default: check_dates=true]
;
; checksum can store the original date and time of the file along with the hash.
; On verification, it is then possible to deduce whether a file has been CHANGED
; (by someone/some process - its timestamp will be different) or CORRUPT (the
; timestamp is the same, but the hash failed)
;
; This will obviously introduce a slight processing overhead, but should be well
; worth it for most users. Also, your .hash files will be almost twice as big.
;
check_dates=true



;
; Reporting level    (for verification only)
;
; NOTE: you need to have check_dates=true (above) for checksum to be able to
; know the  difference between a CHANGED file, and a CORRUPT file, otherwise
; all files with hash fails are simply considered "CHANGED".
;
; Report missing files?                   [bool]  [default: report_missing=true]
;
report_missing=true

;
; Report changed files?                   [bool]  [default: report_changed=true]
;
; Report files which have been modified - their mofified date and time has
; changed since they were hashed AND the hash no longer matches..
;
report_changed=true

;
; Report corrupted files?                 [bool]  [default: report_corrupt=true]
;
; Report failing files with exactly the same timestamp as when originally
; hashed. Unless you are specifically looking for changed or missing files,
; you definitely want this set to TRUE!
;
report_corrupt=true


;
; Delete missing hashes..         [bool]  [default: delete_missing_hashes=false]
;
; command-line switch: x
;
; During a verify operation, checksum can remove the hashes of missing files.
; Use this for areas where you /expect/ missing files.
;
; Note: This can be enabled in your one-shot verify options on a per-job basis.
;
delete_missing_hashes=false


;
; Update CHANGED hashes..         [bool]  [default: update_changed_hashes=false]
;
; command-line switch: w    (think: re'W'rite)
;
; checksum can rewrite the hashes (and timestamp) for files which have CHANGED
; (that is, the data AND the timestamp are different from when originally
; hashed) with fresh hashes. Please use this with caution, on data you know has
; been /mindfully/ changed.
;
; For this to work, you need to have timestamps enabled (check_dates=true).
;
; Note: This can be enabled in your one-shot verify options on a per-job basis.
;
update_changed_hashes=false



;
; Fallback prefs..
;

;
; Fallback level                          [integer]  [default: fallback_level=1]
;
; When checksum is asked to hash a read-only volume, it can't write the
; checksums to the volume itself, and so relies on a fall-back strategy..
;
;    fallback_level=0    carry on as before, except in the fall-back location
;    fallback_level=1    create a "root" checksum in the the fall-back location
;    fallback_level=2    as level 1, except record full, absolute file paths.
;
; For a full explanation of the available fallback levels, see here..
;
; https://corz.org/windows/software/checksum/checksum-prefs.php#fallback_settings
;
fallback_level=1
;

; fall-back folder  [string/path]  [default: fallback_folder=@desktop\checksums]
;
; In the event of creating hashes for files on read-only media, or read-only
; folders on writeable media, checksum will drop the hashes into a fall-back
; folder. By default, they will be placed in a folder called "checksums" on your
; desktop. You can change that location here..
;
fallback_folder=@desktop\checksums

; Note the use of the special token "@desktop". See "log_name" (above) for a full
; description of the other available @tokens.
;
; Note: if you do this a lot, you might want to use @desktop\checksums\@item

;
; resync read-only hashes.               [bool]  [default: resync_readonly=true]
;
; Under fallback conditions, if checksum as asked to sync a read-only folder
; where there is already a (read-only) hash file, normally, checksum will add
; *all* the hashes to the new hash file in the fall-back location, regardless of
; whether or not some of these hashes already exist in the read-only hash file
; in the original location. This potentially creates duplicate hashes, but
; makes your life easier, later on, and saves potential confusion. It's also
; faster.
;
; But you might prefer have checksum only add hashes which do not already exist
; in *both* locations. For example..
;
; If you have a read-only folder with ten files, and seven files already exist
; in the read-only hash file, checksum could create hashes only for the missing
; three, so that between the two files, you have all the hashes. If that suits
; you better, set this to false.
;
resync_readonly=true


;
; Miscellaneous..
;

;
; Playlist Type.
;
; This is for  Winamp/iTunes/foobar2000/Totem/JuK playlists. If you prefer
; utf-8 playlists (recommended), specify m3u8, here. Regular m3u will be ANSI.
playlist_type=m3u8
;
; NOTE: pls playlists are always saved in UTF-8 format.

;
; Allow multiple instances?      [bool/special]  [default: allow_multiple=queue]
;
; This does not default to true, to prevent user's from shooting themselves
; in the foot by trying to run multiple checksum operations on the same
; physical drive, resulting in intense disk-thrashing, and slow operation.
; However, if you know exactly what you are doing, and remember to never
; run two copies of checksum at the same time, on the same physical drive,
; at least for large files, you can enable multiple instances here..
;
allow_multiple=queue
;
; If this is set to true, be careful of launching checksum from Explorer's
; context menu when multiple files and folders are selected, because they
; definitely WILL be on the same drive! HOWEVER...

; There is now a special value you can set, "queue" (no quotes). With
; allow_multiple=queue, checksum will add new jobs to a simple queue file which
; it checks on exit, re-launching itself with each new task until complete.
;
; This works so well, queue has now become the default setting!


;
; Apply initial options to entire queue..
;
; If you select multiple items and choose "checksum" from your Explorer context
; menu with the SHIFT key held down, you will, of course, get the one-shot
; options dialog. By default, checksum will apply whatever options you set for
; the first item to the rest of the queue. If you would prefer to have the
; optins dialog pop up for each item in the queue, set this to false..
;
apply_options_to_queue=true




;
; Process Priority                   [integer]  [default: 2 ("Normal" priority)]
;
; You can set the CPU priority of checksum here. The "Normal" value is 2.
;
;        0 = Idle/Low
;        1 = Below Normal
;        2 = Normal
;        3 = Above Normal
;        4 = High
;        5 = Realtime (Use with caution, may make the system unstable!)
;
cpu_priority=2


;
; One-shot options help tips..                 [bool]  [default: help_tips=true]
;
; Once you know what you are doing, you may want to disable the one-shot
; options helpful pop-up help tips...
;
help_tips=true


;
; Shutdown when done                 [bool]  [default: shutdown_when_done=false]
;
; command-line switch: z
;
; checksum can shutdown your computer at the end of an operation. Handy for
; jobs involving millions of files on systems that don't run 24/7.
;
shutdown_when_done=false


;
; Custom Startup Command..          [string]  [default: startup_command=<blank>]
;
; When checksum is launched with nothing to do, rather than have checksum
; display the "Nothing to do!" dialog, you can have it do something /else/. This
; might be a default checksum command that you use a lot, or another program, or
; something else. e.g..
;
;startup_command=simple checksum.exe
;startup_command=c:\path\to\some\program.exe /foo /bar
;startup_command=c:\path\to\my editors\editor.exe /open "i:\my\document.doc"
;startup_command=c:\some app.exe  c:\some documents\document.txt
;
startup_command=
;
; For checksum commands, send your regular command-line after a "checksum"
; flag; the word "checksum", with a pipe character after it, e.g..
;
;    startup_command=checksum|crtbim(movies) "W:\Completed Torrents"
;    startup_command=checksum|vr .\
;
; And checksum will launch itself with the specified command-line. Simple.
;
; NOTE: If a DOS command isn't working as expected, use the DOS compatibility
; flag "dos", e.g..
;
;    startup_command=dos|compact.exe /C "B:\hashes\*.*"
;
; ALSO NOTE: like many prefs here, you can use @tokens in this setting.
;
; There is also a special "shellex" flag, which I will now explain..
;
; Normally, a command-line is an executable, optionally with some switches
; and parameters required to complete the task. But you may want to launch
; something else, for example a document or URL. For this, you can use the
; "shellex" flag. The "shellex" flag performs a system "Shell Execute", which
; can be used to launch just about any "thing". It goes like this..
;
;    startup_command=shellex|Item|Parameters|Verb|Working Dir
;
; Only the "Item" is required. All others are optional, for example..
;
;    startup_command=shellex|C:\Users\Cor\Desktop\corz.org.URL
;
; which will launch an internet shortcut I have on my desktop. Using the
; "shellex" flag, you could also launch the URL directly..
;
;    startup_command=shellex|https://corz.org/
;
; The default verb is whatever your system would normally do with the path you
; send, usually "Open". But you can (usually, though not always) use any verb
; avalable from your Explorer context menu, e.g..
;
;    startup_command=shellex|C:\Users\Cor\Desktop\page.indd||Print
;
; NOTE: the double || because in this example, I don't want to send any
; parameters but DO want to send a Verb. In other words, if you want to skip a
; previous flag, leave it blank.
;
; Finally, you can also set the scheduler wizard as the startup command, like
; so..
;
; startup_command=schedule



;
; Exit Command
;
; You can have checksum run another command when it has completed its job.
;
; NOTE: you can use @tokens in this setting, including the @exit token, which
; will transform into checksum's exit code, to pass to the program..
;
exit_command=


;
; Exit command switch..
;
; You can enable/disable performing the exit command with the "0" (zero) switch
; (think, standard exit code!)
;
; Add a "0" (no quotes) into your switches to activate the command processing.
; If this is enabled here, you can temporarily disable processing the exit
; command by passing "-0" in your switches..
;
do_exit_command=false



;
; options window location    (-1 means centre, for initial run)
; drag the options window around - these get set automatically, and remembered.
;
opt_x=-1
opt_y=-1




;
; Version Checking..                       [int]  [default: version_checking=-1]
;
; checksum can check online to see if a newer version of checksum is available.
;
; Enter a number here, which will represent the number of days between checks,
; i.e. to check weekly, use: version_checking=7
;
; To disable version checking, set version_checking=0
;
version_checking=-1

x=0
y=0


;
; Custom Stuff..                           [string]  [default: preamble=<blank>]
;
; Registered users get extra custom stuff..

; Preamble..
; You can customize the comment that is inserted at the top of each .hash file
; If you need linegreaks, use "\n" (no quotes).
preamble=

;
; Disable preamble                           [bool]  [default: do_preamble=true]
;
; You can also disable the preamble completely, if you /really/ must!
;
do_preamble=true



;
; Registered To..                            [string]  [default: reg_to=<blank>]
;
; You may /not/ want to display your registered email address in the About Box.
; You can enter some other string, here..
reg_to=
;
; NOTE: Small strings are best - it's a small about box!

;
; Display Edit Prefs Option                [bool]  [default: show_edit_ini=true]
;
; If you don't want your underlings having easy access to the ini file, you can
; disable the option from the tray and context menus, here..
;
show_edit_ini=true

;
; Registration Code
;
; Your shirtware registration code goes here..
; NOTE: You *MUST* the registration input dialog (either presented automatically
; or else accessed via the about box - click the icon)
;
reg_user=
reg_code=https://corz.org/windows/software/checksum/checksum-licensing.php?app=true




; Miscelleneous options..
;


;
; Resize options dialogs..
;
; If you have visual accessibility issues and your system runs with LARGE fonts,
; you can hack some big numbers into here..
;
create_options_width=
create_options_height=
verify_options_width=
verify_options_height=



;
; Hash File Name                      [string]  [default: hashfile_name={blank}]
;
; If you want, you can set a single generic name for your checksum files. This
; only takes effect when hashing folders (checksums for individual files are
; named after the file being hashed). If you sepecify individual hashes above,
; (or command-line "i"), this setting will be ignored.
;
; You can use @tokens in this name. See "log_name" (below) for a full
; description of the available tokens.
;
; If you leave this blank (the default) checksum will name the file
; automatically, depending on the name of the file or folder checked, which is
; essentially the same as using hashfile_name=@item
;
hashfile_name=
;
; You do not need to add an extension; the correct extension will be added
; automatically (unless you want two extensions, that is).
;
; NOTE: characters you add here must be valid on your file system: pipes "|",
; colons ":", quotes """, etc., will void checksum creation.
;
; NOTE: you cannot successfully use the special *directory* @tokens inside file
; "name" settings.
;
;
; NOTE: There is EXPERIMENTAL support (designed for automated folder compare)
; for passing this name in your command line using the "j" switch, enclosing the
; name in braces directly after, like so..
;
;    j(my-hashes)
;
; Also Note, you CANNOT use this in the options dialog switches input. Or
; rather, you /could/, but the behavior would be unpredictable, depending on the
; name used. If people ask for it, I will consider adding this facility to the
; one-shot options.


;
; "Nameless" name
;
; If checksum finds itself having to name a hash file based on a file name with
; /no/ name, only an extension (e.g. ".foobar" or ".htaccess") it will use the
; word "nameless", by default, as the the hash name. You can use something else.
; If you leave this blank you would potentially get ".hash", which may create
; invisible files on some systems, which may be what you want.
;
nameless_name=nameless



; Relaxed Writeability Testing..             [bool]      [relaxed_write_test=false]
;
;
; Normally we use the most accurate method, which is to write an actual test
; file to the directory. However, this will also change the "last modified"
; timestamp on that directory. If you would prefer this to not happen, set this
; to true and checksum will instead rely on the system's "read-only" flag for
; the directory. This works in most ordinary scenarios, but if you ever have a
; "can't create checksums" error, set this to false (the default) and try again!
;
relaxed_write_test=false



;
; Beta Channel                                     [bool]        [beta_channel=false]
;
; You can set this to true to get notified when updated betas become available
; (as well as the major releases). By default this is set to false, so you only
; get notified of major releases.
;
; Major releases supercede all previous beta releases. The beauty of this
; setting is that it will survive switching to a major release when /it/ becomes
; the latest. As soon as a new beta becomes available, you get a  notification.
;
beta_channel=false


;
; Beta Releases Debugging..
;
; If you are testing a beta release, enable this for GOBS of debug output in the
; current working directory. If you need to report a bug, PLEASE send me this
; output, as well as a copy of this ini file. Thanks!
;
do_debug=false

;
;
; other stuff will go in here..
;
;




[file masks]
;
;    file mask groups
;
;    You can create/edit your own groups here, rename these, whatever.
;    These will appear as the drop-down in the creation options dialog.
;
;    Remember, you can use your group names on the command-line, too;
;    e.g..
;
;        checksum.exe crm(music) "c:\downloads"
;
;  IMPORTANT: The group name must NOT contain spaces.
;
music=*.aac,*.aif,*.ape,*.fla,*.flac,*.m4a,*.mp2,*.mp3,*.mpc,*.ogg,*.shn,*.tta,*.wav,*.wma
movies=*.3gp,*.asf,*.avi,*.m4v,*.mkv,*.mov,*.mp4,*.mpe,*.mpeg,*.mpg,*.nsv,*.ogm,*.rm,*.rmvb,*.wmv,*.flv
archives=*.7z,*.ace,*.bz2,*.gz,*.rar,*.sit,*.tar,*.tgz,*.z,*.zip



[dialogs]
; which warnings and stuff you know about already



;
; simple checksum..
;

; That small, but highly useful drag-and-drop checksum app..
;
[simple checksum]
transparency=0
algorithm=md5
uppercase=false"