"    Input:  {
              (host_os)                    - host OS (detect, if omitted)
              (target_os)                  - OS module to check (if omitted, analyze host)
              (device_id)                  - device id if remote (such as adb)

              (once)                       - if 'yes', run scenario once (useful for autotuning a given program)

              (iterations)                 - limit number of iterations, otherwise infinite (default=30)
                                             if -1, infinite (or until all choices are explored)

              (repetitions)                - statistical repetitions of a given experiment

              (compiler_description_uoa)   - force compiler description UOA (see module "compiler")
              (flag_tags)                  - extra flag tags (must have)
              (any_flag_tags)              - extra flag tags (any of these)

              (quiet)                      - do not ask questions, but select random ...
              (skip_welcome)               - if 'yes', do not print welcome header

              (skip_exchange)              - if 'yes', do not exchange platform info
                                            (development mode)

              (user)                       - user email/ID to record solutions (attribute found good solutions)

              (local)                      - if 'yes', use local repo for exchange (local autotuning/benchmarking)
              (exchange_repo)              - which repo to record/update info (remote-ck by default)
              (exchange_subrepo)           - if remote, remote repo UOA

              (record_repo)                - repo where to search/record local experiments
                                             ("local" by default, to avoid polluting other repos)

              (local_autotuning)           - if 'yes', do not crowdtune, i.e. find local experiment and do not exchnage results

              (force_platform_name)        - if !='', use this for platform name

              (scenario)                   - module UOA of crowdsourcing scenario
              (scenario_cfg)               - cfg of a scenario

              (seed)                       - autotuning seed

              (program_tags)               - force selection of programs by tags

              (program_uoa)                - force program UOA
              (cmd_key)                    - CMD key
              (cmd_keys)                   - Select only from this list of available CMD keys

              (dataset_uoa)                - dataset UOA
              (dataset_file)               - dataset filename (if more than one inside one entry - suggest to have a UID in name)

              (extra_dataset_tags)         - list of extra data set tags (useful to set "small" during mobile phone crowdtuning)

              (calibration_time)           - change calibration time (deafult 10 sec.)

              (objective)                  - extension to flat characteristics (min,exp,mean,center) to tune on Pareto
                                             (default: min - to see what we can squeeze from a given architecture)

              (keep_tmp)                   - if 'yes', do not remove run batch

              (ask_pipeline_choices)       - if 'yes', ask for each pipeline choice, otherwise random selection 

              (platform_info)              - detected platform info

              (experiment_meta)            - meta when recording experiment
              (experiment_meta_extra)      - extra meta such as platform UIDs

               (record_failed)                    - if 'yes', record even failed experiments
                                                    (for debugging, buildbots, detecting designed 
                                                     architecture failures, etc)
               (record_only_failed)               - if 'yes', record only failed experiments
                                                    (useful to crowdsource experiments when searching only 
                                                     for compiler/program/architecture bugs  
                                                     (for example fuzzing via random compiler flags))...

              (record_uoa)                 - use this UOA to recrod experiments instead of randomly generated ones

              (solution_conditions)        - list of conditions:
                                               ["first key", "extra key", "condition", value]

              (pause_if_fail)              - if pipeline fails, ask to press Enter
                                             (useful to analyze which flags fail during compiler flag autotuning)

              (omit_probability)           - probability to omit optimization (for example, compiler flags during exploration/crowdtuning)
              (parametric_flags)           - if 'yes', also tune parametric flags
              (cpu_flags)                  - if 'yes', also tune cpu-specific flags
              (base_flags)                 - if 'yes', also tune base flag

              (compiler_env_uoa)           - fix compiler environment

              (new)                        - if 'yes', do not search for existing experiment, but start new

              (solutions)                  - list of solutions
              (solutions_info)             - info (repo_uoa, module_uoa, data_uoa)

              (solution_module_uoa)        - if !='' use it to reuse shared optimization cases
              (solution_data_uoa)          - force specific solution entry
              (solution_repo_uoa)          - force repo where to search existing solutions
              (solution_remote_repo_uoa)   - force sub-repo (if above repo is remote)

              (prune)                      - prune solution (find minimal choices that give the same result)
              (reduce)                     - the same as above
              (reduce_bug)                 - reduce choices to localize bug (pipeline fail)
              (prune_md5)                  - if 'yes', check if MD5 doesn't change
              (prune_invert)               - prune all (turn off even swiched off)

              (replay)                     - if 'yes', replay

              (record_reactions)            - if 'yes', record optimization reaction
              (record_reactions_file)       - file to record reaction table for graph ...

              (record_solutions)            - if 'yes', record solutions
              (solutions_file)              - output solutions to a file

              (skip_pruning)                - if 'yes', do not prune best found result during crowdtuning

              (skip_collaborative)          - do not check collaborative solutions (useful for "clean" autotuning)

              (no_run)                      - if 'yes', do not run program - useful for generating experiments pack
                                              for crowtuning using Android mobile phones
            }

    Output: {
              return       - return code =  0, if successful
                                         >  0, if error
              (error)      - error text if return > 0

              (solutions)  - if 'solutions' present in input, possibly updated ones will present in output too (replay)
            }

"