<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 async def minizinc( mzn, *dzn_files, args=None, data=None, include=None, stdlib_dir=None, globals_dir=None, declare_enums=True, allow_multiple_assignments=False, keep=False, output_vars=None, output_base=None, output_mode='dict', solver=None, timeout=None, two_pass=None, pre_passes=None, output_objective=False, non_unique=False, all_solutions=False, num_solutions=None, free_search=False, parallel=None, seed=None, rebase_arrays=True, keep_solutions=True, return_enums=False, max_queue_size=0, **kwargs ):
 """Coroutine version of the ``pymzn.minizinc`` function. Parameters max_queue_size : int Maximum number of solutions in the queue between the solution parser and the returned solution stream. When the queue is full, the solver execution will halt untill an item of the queue is consumed. This option is useful for memory management in cases where the solution stream gets very large and the caller cannot consume solutions as fast as they are produced. Use with care, if the full solution stream is not consumed before the execution of the Python program ends it may result in the solver becoming a zombie process. Default is ``0``, meaning an infinite queue. """


    mzn_file, dzn_files, data_file, data, keep, _output_mode, types = \
        _minizinc_preliminaries(
            mzn, *dzn_files, args=args, data=data, include=include,
            stdlib_dir=stdlib_dir, globals_dir=globals_dir,
            output_vars=output_vars, keep=keep, output_base=output_base,
            output_mode=output_mode, declare_enums=declare_enums,
            allow_multiple_assignments=allow_multiple_assignments
        )

    if not solver:
        solver = config.get('solver', gecode)

    solver_args = {**kwargs, **config.get('solver_args', {})}

    proc = await solve(
        solver, mzn_file, *dzn_files, data=data, include=include,
        stdlib_dir=stdlib_dir, globals_dir=globals_dir,
        output_mode=_output_mode, timeout=timeout, two_pass=two_pass,
        pre_passes=pre_passes, output_objective=output_objective,
        non_unique=non_unique, all_solutions=all_solutions,
        num_solutions=num_solutions, free_search=free_search, parallel=parallel,
        seed=seed, allow_multiple_assignments=allow_multiple_assignments,
        **solver_args
    )

    if output_mode == 'raw':
        solns = asyncio.Queue(maxsize=max_queue_size)
        task = asyncio.create_task(_collect(proc, solns))
    else:
        parser = AsyncSolutionParser(
            solver, output_mode=output_mode, rebase_arrays=rebase_arrays,
            types=types, keep_solutions=keep_solutions,
            return_enums=return_enums, max_queue_size=max_queue_size
        )
        solns = await parser.parse(proc)
        task = parser.parse_task

    if not keep:
        task.add_done_callback(partial(_cleanup_cb, [mzn_file, data_file]))

    return solns