def bonetrousle(n, k, b):
    """Find b distinct integers in [0,...,k] that sum to n."""
    
    # Define these convenient variables:
    N = n - b*(b+1)//2
    d = k - b
    
    # For a solution to exist, n must lie between the sum of first b boxes and the last b boxes
    if (N < 0) or (N > b*d):
        return [-1]
    elif N == 0:  # edge case when d==0
        return [*range(1, b+1)]
    else:
        # Imagine starting with first b boxes. While keeping the sum below n, replace b->k, (b-1)->(k-1), .... Each shift adds d to the total. Finally add the missing balance to the "next" (b-i) term. (i.e. the largest value in [1,2,..b] that didn't get shifted.)
        q, r = N//d, N % d
        # Take care of edge case with b-q+r==0 
        mid = [] if (b == q-r) else [b-q+r]
        return [*range(1, b-q)] + mid + [*range(k, k-q, -1)]

void bonetrousle(uint64_t n, uint64_t k, uint64_t b,ostream& fout) {
    uint64_t min = (b * (1 + b)) / 2;
    // uint64_t max = (b * ((k - b + 1) + k)) / 2; <-- This overflows, use a different formula to reduce the size of intermediate results...
    uint64_t max = k * b - b * (b - 1) / 2; // Doesn't overflow.
    
    if(min > n || max < n) {
        fout << "-1" << endl;
        return;
    }
    
    // We can add this many sticks to each box (quotient).
    int64_t q = (n - min) / b;
    // These additional sticks can be distributed after that (remainder).
    uint64_t r = (n - min) % b;
    
    for(int64_t i = 1; i <= b; ++i) {
        // Our number in sequence order, offset by our quotient.
        int64_t num = i + q;
        
        // Replacing num would add our missing remainder to the sum and thus complete it.
        if (r > 0 && (b + q + 1) - num == r) {
        // Example: b is 4, q is 0, and r is 2 which means our sequence is 1 2 3 4.
        // We have to find a way to increase the sum by 2, from 10 to 12.
        // b + q will always be the highest numbers in the sequence, in this case 4,
        // and we simply add 1 (b + q + 1) to get the next number in our sequence (5): this is the number we want to replace some num with so that we increase our total by r.
        // 5 = num - 2, so in this case we would replace 3 and end up with the sequence 1 2 5 4 which has a sum of 12!
            fout << b + 1 + q;
        } else {
            fout << num;
        }
        
        if(i < b) {
            fout << " ";
        }
    }
    
    fout << endl;
}

def bonetrousle(n, k, b):
    mini=maxi=0
    res=[0]*b
    temp=1
    while temp<=b:
        mini+=temp
        maxi+=k-temp+1
        temp+=1
    if n>=mini and n<=maxi:
        q=(n-mini)//b
        r=(n-mini)%b
        for i in range(b):
            res[i]+=(q+i+1)
        for i in range(1,r+1):
            res[-i]+=1
        return res
    else:
        return [-1]