// Generator Mersenne Twister
// Data   : 16.04.2008
// (C)2020 mgr Jerzy Wałaszek
//---------------------------

program prg;

uses SysUtils, DateUtils;

var

  MT  : array [0..623] of longword;
  mti : integer;

// Inicjuje MT []
//--------------
procedure InicjujMT (x0 : longword);

var
  i : integer;
  x : qword;
begin
  MT[0] := x0;
  for i := 1 to 623 do
  begin
    x := MT[i-1];
    x := (23023*x) and $00000000ffffffff;
    x := (    3*x) and $00000000ffffffff;
    MT[i] := x;
  end;
  mti := 0;
end;

// Inicjuje MT wartościami losowymi
//---------------------------------
procedure UprzypadkowijMT;

var
  t  : TDateTime;
  x0 : longword;
begin
  t  := Now;
  x0 := HourOf(t);
  x0 := x0*  60+MinuteOf(t);
  x0 := x0*  60+SecondOf(t);
  x0 := x0*1000+MillisecondOf(t);
  InicjujMT(x0);
end;

// Generator Mersenne Twister
//--------------------------
function MersenneTwister : longword;
const
  MA : array [0..1] of longword = (0, $9908b0df);
var
  y : longword;
  i1, i397 : integer;
begin
  i1   := mti+  1; if   i1 > 623 then i1 := 0;
  i397 := mti+397; if i397 > 623 then dec(i397, 624);
  y    := (MT[mti] and $80000000) or (MT[i1] and $7fffffff);
  MT[mti] := MT[i397] xor (y shr 1) xor MA[y and 1];
  y    := MT[mti];
  y    := y xor (y shr 11);
  y    := y xor ((y shl  7) and $9d2c5680);
  y    := y xor ((y shl 15) and $efc60000);
  y    := y xor (y shr 18);
  mti  := i1;
  MersenneTwister := y;
end;

var
  a, b, i, n : longint;
begin
  UprzypadkowijMT;
  readln(a, b, n);
  for i := 1 to n do
    write(a+(MersenneTwister mod (b-a+1)), ' ');
  writeln;
end.

// Generator Mersenne Twister
// Data   : 16.04.2008
// (C)2020 mgr Jerzy Wałaszek
//---------------------------

#include <iostream>

using namespace std;

typedef unsigned long long ulong;

unsigned int MT[624];
int mti = 0;

// Inicjuje MT[]
//-------------
void InicjujMT(unsigned int x0)
{
  ulong x;

  MT[0] = x0;
  for(int i = 1; i < 623; i++)
  {
    x = MT[i-1];
    x = (23023*x) & 0xffffffffull;
    x = (    3*x) & 0xffffffffull;
    MT[i] = x;
  }
}

// Inicjuje MT wartościami losowymi
//---------------------------------
void UprzypadkowijMT()
{
  InicjujMT((unsigned int)time(NULL));
}

// Generator Mersenne Twister
//--------------------------
unsigned int MersenneTwister()
{
  const unsigned int MA[] = {0, 0x9908b0df};
  long int y;
  int i1, i397;

  i1      = mti+  1; if(  i1 > 623) i1    = 0;
  i397    = mti+397; if(i397 > 623) i397 -= 624;
  y       = (MT[mti] & 0x80000000) | (MT[i1] & 0x7fffffff);
  MT[mti] = MT[i397] ^ (y >> 1) ^ MA[y & 1];
  y       = MT[mti];
  y      ^=  y >> 11;
  y      ^= (y <<  7) & 0x9d2c5680;
  y      ^= (y << 15) & 0xefc60000;
  y      ^=  y >> 18;
  mti     = i1;
  return y;
}

int main()
{
  int a, b, i, n;

  UprzypadkowijMT();
  cin >> a >> b >> n;
  for(i = 1; i <= n; i++)
    cout << (a+(MersenneTwister() % (b-a+1))) << " ";
  cout << endl << endl;

  return 0;
}

' Generator Mersenne Twister
' Data   : 16.04.2008
' (C)2020 mgr Jerzy Wałaszek
'---------------------------

Dim Shared MT(623) As Uinteger
Dim Shared mti As Integer = 0

' Inicjuje MT[]
'-------------
Sub InicjujMT(Byval x0 As Uinteger)

  Dim i As Integer, x As Ulongint

  MT (0) = x0
  For i = 1 To 623
    x = MT(i-1)
    x = (23023*x) And &Hffffffff
    x = (    3*x) And &Hffffffff
    MT(i) = x
  Next 
End Sub

' Inicjuje MT wartościami losowymi
'---------------------------------
Sub UprzypadkowijMT()
  InicjujMT(Timer*1000)
End Sub

' Generator Mersenne Twister
'--------------------------
Function MersenneTwister() As Uinteger

  Dim MA(1) As Uinteger => {0, &H9908b0df}
  Dim y As Uinteger
  Dim As Integer i1, i397

  i1      = mti+  1: If   i1 > 623 Then i1 = 0
  i397    = mti+397: If i397 > 623 Then i397 -= 624
  y       = (MT(mti) And &H80000000) Or (MT(i1) And &H7fffffff)
  MT(mti) = MT(i397) Xor (y Shr 1) Xor MA (y And 1)
  y       = MT (mti)
  y       = y Xor (y  Shr 11)
  y       = y Xor ((y Shl  7) And &H9d2c5680)
  y       = y Xor ((y Shl 15) And &Hefc60000)
  y       = y Xor (y  Shr 18)
  mti     = i1
  MersenneTwister = y
End Function

Dim As Integer a, b, i, n

UprzypadkowijMT()
Open Cons For Input As #1
Input #1, a, b, n
Close #1
For i = 1 To n
  Print a+(MersenneTwister() Mod (b-a+1));
Next
Print
End

# Generator Mersenne Twister
# Data   : 16.02.2024
# (C)2024 mgr Jerzy Wałaszek
# ---------------------------

import time

# Zmienne globalne
mt = []
mti = 0


# Inicjuje MT[]
# -------------
def inicjuj_mt(x0):
    global mt
    mt.append(x0)
    for i in range(1, 624):
        x = mt[i-1]
        x = (23023*x) & 0xffffffff
        x = (    3*x) & 0xffffffff
        mt.append(x)
    return


# Inicjuje MT wartościami losowymi
# ---------------------------------
def uprzypadkowij_mt():
    inicjuj_mt(int(time.time()*1000))
    return


# Generator Mersenne Twister
# --------------------------
def mersenne_twister():
    global mti, mt
    ma = [0, 0x9908b0df]
    i1 = mti+1
    if i1 > 623: i1 = 0
    i397 = mti+397
    if i397 > 623: i397 -= 624
    y = (mt[mti] & 0x80000000) | (mt[i1] & 0x7fffffff)
    mt[mti] = mt[i397] ^ (y >> 1) ^ ma[y & 1]
    y = mt[mti]
    y ^= y >> 11
    y ^= (y << 7) & 0x9d2c5680
    y ^= (y << 15) & 0xefc60000
    y ^= y >> 18
    mti = i1
    return y

uprzypadkowij_mt()
arr = input().split()
a = int(arr[0])
b = int(arr[1])
n = int(arr[2])
for i in range(n):
    print(a+(mersenne_twister() % (b-a+1)), end=" ")
print()