

__A			:					List[str]						=			range(2, 2_0 + 1)
__A			:					List[str]						=			[1_0**k for k in range(ks[-1] + 1)]
__A			:					dict[int, dict[int, list[list[int]]]]						=			{}





def 	__a     (      A__			:  List[Any]			,  A__			:  Union[str, Any]			,  A__			:  List[Any]			,  A__			:  Any       ):
    SCREAMING_SNAKE_CASE										=   sum(a_i[j] for j in range(A__			,  len(A__       )       )       )
    SCREAMING_SNAKE_CASE										=   sum(a_i[j] * base[j] for j in range(min(len(A__       )			,  A__       )       )       )

    SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   0, 0
    SCREAMING_SNAKE_CASE										=   n - i

    SCREAMING_SNAKE_CASE										=   memo.get(A__       )

    if sub_memo is not None:
        SCREAMING_SNAKE_CASE										=   sub_memo.get(A__       )

        if jumps is not None and len(A__       ) > 0:
            # find and make the largest jump without going over
            SCREAMING_SNAKE_CASE										=   -1
            for _k in range(len(A__       ) - 1			,  -1			,  -1       ):
                if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
                    SCREAMING_SNAKE_CASE										=   _k
                    break

            if max_jump >= 0:
                SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   jumps[max_jump]
                # since the difference between jumps is cached, add c
                SCREAMING_SNAKE_CASE										=   diff + c
                for j in range(min(A__			,  len(A__       )       )       ):
                    SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   divmod(A__			,  10       )
                if new_c > 0:
                    add(A__			,  A__			,  A__       )

        else:
            SCREAMING_SNAKE_CASE										=   []
    else:
        SCREAMING_SNAKE_CASE										=   {c: []}
        SCREAMING_SNAKE_CASE										=   sub_memo

    if dn >= max_dn or c + diff >= base[k]:
        return diff, dn

    if k > ks[0]:
        while True:
            # keep doing smaller jumps
            SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   next_term(A__			,  k - 1			,  i + dn			,  A__       )
            diff += _diff
            dn += terms_jumped

            if dn >= max_dn or c + diff >= base[k]:
                break
    else:
        # would be too small a jump, just compute sequential terms instead
        SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   compute(A__			,  A__			,  i + dn			,  A__       )
        diff += _diff
        dn += terms_jumped

    SCREAMING_SNAKE_CASE										=   sub_memo[c]

    # keep jumps sorted by # of terms skipped
    SCREAMING_SNAKE_CASE										=   0
    while j < len(A__       ):
        if jumps[j][1] > dn:
            break
        j += 1

    # cache the jump for this value digitsum(b) and c
    sub_memo[c].insert(A__			,  (diff, dn, k)       )
    return (diff, dn)





def 	__a     (      A__			:  Any			,  A__			:  List[str]			,  A__			:  Any			,  A__			:  Union[str, Any]       ):
    if i >= n:
        return 0, i
    if k > len(A__       ):
        a_i.extend([0 for _ in range(k - len(A__       )       )]       )

    # note: a_i -> b * 10^k + c
    # ds_b -> digitsum(b)
    # ds_c -> digitsum(c)
    SCREAMING_SNAKE_CASE										=   i
    SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   0, 0, 0
    for j in range(len(A__       )       ):
        if j >= k:
            ds_b += a_i[j]
        else:
            ds_c += a_i[j]

    while i < n:
        i += 1
        SCREAMING_SNAKE_CASE										=   ds_c + ds_b
        diff += addend
        SCREAMING_SNAKE_CASE										=   0
        for j in range(A__       ):
            SCREAMING_SNAKE_CASE										=   a_i[j] + addend
            SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   divmod(A__			,  10       )

            ds_c += a_i[j]

        if addend > 0:
            break

    if addend > 0:
        add(A__			,  A__			,  A__       )
    return diff, i - start_i





def 	__a     (      A__			:  str			,  A__			:  List[str]			,  A__			:  List[Any]       ):
    for j in range(A__			,  len(A__       )       ):
        SCREAMING_SNAKE_CASE										=   digits[j] + addend
        if s >= 10:
            SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   divmod(A__			,  10       )
            SCREAMING_SNAKE_CASE										=   addend // 10 + quotient
        else:
            SCREAMING_SNAKE_CASE										=   s
            SCREAMING_SNAKE_CASE										=   addend // 10

        if addend == 0:
            break

    while addend > 0:
        SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   divmod(A__			,  10       )
        digits.append(A__       )





def 	__a     (      A__			:  int = 10**15       ):
    SCREAMING_SNAKE_CASE										=   [1]
    SCREAMING_SNAKE_CASE										=   1
    SCREAMING_SNAKE_CASE										=   0
    while True:
        SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   next_term(A__			,  20			,  i + dn			,  A__       )
        dn += terms_jumped
        if dn == n - i:
            break

    SCREAMING_SNAKE_CASE										=   0
    for j in range(len(A__       )       ):
        a_n += digits[j] * 10**j
    return a_n


if __name__ == "__main__":
    print(f'{solution() = }')




import faiss  # noqa: F401 # Here to have a nice missing dependency error message early on
import numpy  # noqa: F401 # Here to have a nice missing dependency error message early on
import requests  # noqa: F401 # Here to have a nice missing dependency error message early on
import sklearn  # noqa: F401 # Here to have a nice missing dependency error message early on
import tqdm  # noqa: F401 # Here to have a nice missing dependency error message early on
from mauve import compute_mauve  # From: mauve-text

import datasets


_lowercase    	=		"\\n@inproceedings{pillutla-etal:mauve:neurips2021,\n  title={MAUVE: Measuring the Gap Between Neural Text and Human Text using Divergence Frontiers},\n  author={Pillutla, Krishna and Swayamdipta, Swabha and Zellers, Rowan and Thickstun, John and Welleck, Sean and Choi, Yejin and Harchaoui, Zaid},\n  booktitle = {NeurIPS},\n  year      = {2021}\n}\n\n"

_lowercase    	=		"\\nMAUVE is a library built on PyTorch and HuggingFace Transformers to measure the gap between neural text and human text with the eponymous MAUVE measure.\n\nMAUVE summarizes both Type I and Type II errors measured softly using Kullback–Leibler (KL) divergences.\n\nFor details, see the MAUVE paper: https://arxiv.org/abs/2102.01454 (Neurips, 2021).\n\nThis metrics is a wrapper around the official implementation of MAUVE:\nhttps://github.com/krishnap25/mauve\n"

_lowercase    	=		"\nCalculates MAUVE scores between two lists of generated text and reference text.\nArgs:\n    predictions: list of generated text to score. Each predictions\n        should be a string with tokens separated by spaces.\n    references: list of reference for each prediction. Each\n        reference should be a string with tokens separated by spaces.\nOptional Args:\n    num_buckets: the size of the histogram to quantize P and Q. Options: 'auto' (default) or an integer\n    pca_max_data: the number data points to use for PCA dimensionality reduction prior to clustering. If -1, use all the data. Default -1\n    kmeans_explained_var: amount of variance of the data to keep in dimensionality reduction by PCA. Default 0.9\n    kmeans_num_redo: number of times to redo k-means clustering (the best objective is kept). Default 5\n    kmeans_max_iter: maximum number of k-means iterations. Default 500\n    featurize_model_name: name of the model from which features are obtained. Default 'gpt2-large' Use one of ['gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'].\n    device_id: Device for featurization. Supply a GPU id (e.g. 0 or 3) to use GPU. If no GPU with this id is found, use CPU\n    max_text_length: maximum number of tokens to consider. Default 1024\n    divergence_curve_discretization_size: Number of points to consider on the divergence curve. Default 25\n    mauve_scaling_factor: \"c\" from the paper. Default 5.\n    verbose: If True (default), print running time updates\n    seed: random seed to initialize k-means cluster assignments.\nReturns:\n    mauve: MAUVE score, a number between 0 and 1. Larger values indicate that P and Q are closer,\n    frontier_integral: Frontier Integral, a number between 0 and 1. Smaller values indicate that P and Q are closer,\n    divergence_curve: a numpy.ndarray of shape (m, 2); plot it with matplotlib to view the divergence curve,\n    p_hist: a discrete distribution, which is a quantized version of the text distribution p_text,\n    q_hist: same as above, but with q_text.\nExamples:\n\n    >>> # faiss segfaults in doctest for some reason, so the .compute call is not tested with doctest\n    >>> import datasets\n    >>> mauve = datasets.load_metric('mauve')\n    >>> predictions = [\"hello there\", \"general kenobi\"]\n    >>> references = [\"hello there\", \"general kenobi\"]\n    >>> out = mauve.compute(predictions=predictions, references=references) # doctest: +SKIP\n    >>> print(out.mauve) # doctest: +SKIP\n    1.0\n"



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION      ,   _KWARGS_DESCRIPTION  )
class      _UpperCAmelCase      (							datasets.Metric  ):




     def 		snake_case_		(					self):
         return datasets.MetricInfo(
             description=_DESCRIPTION			,    citation=_CITATION			,    homepage='''https://github.com/krishnap25/mauve'''			,    inputs_description=_KWARGS_DESCRIPTION			,    features=datasets.Features(
                 {
                     '''predictions''': datasets.Value('''string'''			,    id='''sequence'''),
                     '''references''': datasets.Value('''string'''			,    id='''sequence'''),
                 })			,    codebase_urls=['''https://github.com/krishnap25/mauve''']			,    reference_urls=[
                 '''https://arxiv.org/abs/2102.01454''',
                 '''https://github.com/krishnap25/mauve''',
             ]			,    )




     def 		snake_case_		(					self			,    a__			,    a__			,    a__=None			,    a__=None			,    a__=None			,    a__=None			,    a__="auto"			,    a__=-1			,    a__=0.9			,    a__=5			,    a__=5_0_0			,    a__="gpt2-large"			,    a__=-1			,    a__=1_0_2_4			,    a__=2_5			,    a__=5			,    a__=True			,    a__=2_5			,    ):
         A__					=       compute_mauve(
             p_text=a__			,    q_text=a__			,    p_features=a__			,    q_features=a__			,    p_tokens=a__			,    q_tokens=a__			,    num_buckets=a__			,    pca_max_data=a__			,    kmeans_explained_var=a__			,    kmeans_num_redo=a__			,    kmeans_max_iter=a__			,    featurize_model_name=a__			,    device_id=a__			,    max_text_length=a__			,    divergence_curve_discretization_size=a__			,    mauve_scaling_factor=a__			,    verbose=a__			,    seed=a__			,    )
         return out
