#include <assert.h>
#include <iostream>
#include <fstream>
#include <cmath>
#include <vector>
#include <string>

class Range {
private:
    int* data_;
    int size_;

public:
    class Iterator {
    private:
        int* data_begin_;
        size_t size_;

    public:
        Iterator(int* data_begin, size_t size)
        : data_begin_(data_begin), size_(size)
        {}

        // copy constructor
        Iterator(const Iterator& other) {
            size_ = other.size_;
            data_begin_ = new int[size_];
        }

        // assignment operator
        Iterator& operator =(const Iterator& other) {
            assert(size_ > 0);

            if (this == &other) {
                return *this;
            }

            size_ = other.size_;
            data_begin_ = new int[size_];
            return *this;
        }

        bool operator ==(const Iterator& other) {
            return data_begin_ == other.data_begin_ && size_ == other.size_;
        }

        bool operator !=(const Iterator& other) {
            return !(*this == other);
        }

        Iterator& operator ++() {
            assert(size_ > 0);

            data_begin_++;
            size_ -= 1;

            return *this;
        }

        int& operator *() {
            return *data_begin_;
        }
    };

    Iterator begin() {
        return Iterator(data_, size_);
    }
    Iterator end() {
        return Iterator(data_ + size_, 0);
    }

    // constructors
    Range() {}

    explicit Range(const int& s_end) {
        assert(s_end > 0);

        int index = 0;
        size_ = s_end;
        // std::cout << size_ << "size_" << std::endl;
        data_ = new int[size_];

        for (int it = 0; it < size_; ++it) {
            data_[it] = index;
            // std::cout << data_[it];
            index++;
        }
    }

    Range(const int& s_begin, const int& s_end) {
        assert(s_end - s_begin > 0);

        int index = s_begin;
        size_ = s_end - s_begin;
        data_ = new int[size_];

        for (int it = 0; it < size_; ++it) {
            data_[it] = index;
            // std::cout << data_[it];
            index++;
        }
    }

    Range(const int& s_begin, const int& s_end, const int gap) {
        assert((s_end - s_begin > 0 && gap > 0)
               || (s_end - s_begin < 0 && gap < 0));

        int index = s_begin;
        size_ = std::abs((std::abs(s_end - s_begin) - 1) / gap) + 1;
        data_ = new int[size_];
        for (int it = 0; it < size_; ++it) {
            data_[it] = index;
            index += gap;
        }
    }

    // destructor
    ~Range() {
        delete [] data_;
        data_ = nullptr;
    }

    // copy constructor
    Range(const Range& other) {
        size_ = other.size_;
        data_ = new int[size_];
    }

    // assignment operator
    Range& operator = (const Range& other) {
        if (this == &other) {
            return *this;
        }

        delete [] data_;
        data_ = nullptr;

        size_ = other.size_;
        data_ = new int[size_];

        for (int i = 0; i < size_; ++i) {
            data_[i] = other.data_[i];
        }
        return *this;
    }

    Range readFromInput() {
        std::vector<int> num_of_args;
        std::string str;
        std::ifstream fin("input.txt");
        int count = 0;
        fin >> str;
        Range range_rez;
        while (!fin.eof()) {
            num_of_args.push_back(std::stoi(str));
            // std::cout << num_of_args[count] << std::endl;
            count++;
            fin >> str;
        }
        fin.close();
        // std::cout << count;
        if (count == 1) {
            Range range(num_of_args[0]);
            range_rez = range;
            return range;
        } else if (count == 2) {
            Range range(num_of_args[0], num_of_args[1]);
            range_rez = range;
            return range;
        } else {
            Range range(num_of_args[0], num_of_args[1], num_of_args[2]);
            range_rez = range;
            return range;
        }
        for (int it = 0; it < range_rez.size_; ++it) {
            std::cout << range_rez.data_[it] << std::endl;
        }
        return *this;
    }

    void out() {
        for (Iterator it = begin(); it != end(); it.operator++()) {
            std::cout << *it << std::endl;
        }
    }

    size_t size() const {
        return size_;
    }
};

int main() {
    Range result;
    result.readFromInput();
    result.out();
    return 0;
}