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

class Range {
 private:
    int begin_;
    int end_;
    int step_;
    int size_;
    int* data_;
    bool up_;

 public:
// Constructors
// Constructor for 2 operands
    Range(const int& begin, const int& end) {
        begin_ = begin;
        end_ = end;
        step_ = 1;
        size_ = std::abs(end_ - begin_);
        data_ = new int[size_];
        up_ = begin_ < end_;
        int j = -1;
        if ( up_ ) {
            for ( int i = begin_; i < end_; i += step_ ) {
                j++;
                data_[j] = i;
            }
        } else {
            for (int i = begin_; i > end_; i -= step_) {
                j++;
                data_[j] = i;
            }
        }
    }

// Constructor for 1 operand
    explicit Range(const int& end) {
        int j = -1;
        end_ = end;
        begin_ = 0;
        size_ = std::abs(end_);
        data_ = new int[size_];
        step_ = 1;
        up_ = begin_ < end_;
        if (up_) {
            for (int i = begin_; i < end_; i += step_) {
                j++;
                data_[j] = i;
            }
        } else {
            for (int i =  begin_;  i > end_; i -= step_) {
                j++;
                data_[j] = i;
            }
        }
    }

// Constructor for 3 operands

    Range(const int& begin, const int& end, const int step) {
        int j = -1;
        begin_ = begin;
        end_ = end;
        step_ = step;
        size_ = std::abs((std::abs(end_ - begin_)-1)/step_)+1;
        data_ = new int[size_];
        up_ = step_ > 0;
        if (up_) {
            for (int i = begin_;  i < end_;  i += step_) {
                j++;
                data_[j] = i;
            }
        } else {
            for (int i = begin_;  i > end_;  i += step_) {
                j++;
                data_[j] = i;
            }
        }
    }
    // Creating Iterator class
    class Iterator {
     private:
            int* data_begin_;
            int size_;

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

            Iterator(Iterator &other) {
                size_ = other.size_;
                data_begin_ = other.data_begin_;
              }
            Iterator& operator ++() {
                assert(size_ > 0);

                data_begin_++;
                size_ -= 1;
                return *this;
            }
            int& operator *() {
                return *data_begin_;
            }
            bool operator ==(Iterator &other) {
                if ((*data_begin_ == *other.data_begin_) && (size_ == other.size_)) {
                    return true;
                } else {
                    return false;
                }
            }
           bool operator !=(Iterator other) {
                return !(*this == other);
            }

           Iterator operator =(Iterator other) {
                assert(size_ > 0);

                if (this == &other) {
                    return *this;
                }
                size_ = other.size_;
                data_begin_ = other.data_begin_;
                return *this;
            }
            Iterator(const Iterator &other) {
            *data_begin_ = *other.data_begin_;
            size_ = other.size_;
        }
    };
    Iterator begin() {
        return Iterator(data_, size_);
    }

    Iterator end() {
        return Iterator(data_ + size_, 0);
    }
    void out() {
        for (Iterator it = begin(); it != end(); ++it) {
            std::cout << *it <<std::endl;
        }
    }
};

Range input_range() {
    std::vector<int> in_vec(3);
    int i = 0;
    while (std::cin >> in_vec[i]) {
       i++;
    }
    if ( i == 1 ) {
        Range r = Range(in_vec[0]);
        return r;
    }

    if (i == 2) {
        Range r = Range(in_vec[0], in_vec[1]);
        return r;
    }
    if (i == 3) {
        Range r = Range(in_vec[0], in_vec[1], in_vec[2]);
        return r;
    }
    }

int main() {
    input_range().out();
    return 0;
}