//Himanshu Shukla
#pragma GCC optimize("O2")
#include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0)
//#define file_input
//#define multitest
//#define measure_time
#define ll long long
#define v32 vector<int>
#define v64 vector<ll>
#define s32 set<int>
#define s64 set<ll>
#define graph vector<s32>
#define p32 pair<int, int>
#define p64 pair<ll, ll>
#define fi first
#define se second
#define ln '\n'
#define debug(x) cerr << (#x) << ": " << (x) << ln
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline ll add(ll a, ll b, ll m) { return (((a % m + b % m) % m + m) % m); }
inline ll mul(ll a, ll b, ll m) { return (((a % m * b % m) % m + m) % m); }
const double EPS = 1e-6;
const ll MOD = 1e9 + 7;
template <typename T, typename U>
ostream &operator<<(ostream &out, const pair<T, U> &p)
{
	out << '[' << p.fi << ", " << p.se << ']';
	return out;
}
template <template <typename, typename...> class ContainerType, typename ValueType, typename... Args>
void print_container(const ContainerType<ValueType, Args...> &c)
{
	cout << "{ ";
	for (const auto &v : c)
		cout << v << ' ';
	cout << '}' << ln;
}

int dp[305][305][305];
int dp1[305][305][305];

int go(int i, int j, int k, int a, int b, int n, string &str)
{
	if ((j - i + 1) >= a && (j - i + 1) <= b && k == 0)
	{
		dp[i][j][k] = (j - i + 1);
		dp1[i][j][k] = 1;
		return 1;
	}
	if (k == 0 && ((j - i + 1) < a || (j - i + 1) > b))
	{
		dp[i][j][k] = 0;
		dp1[i][j][k] = 0;
		return 0;
	}
	if (dp1[i][j][k] != -1)
		return dp1[i][j][k];
	int ans = 0;
	for (int l = a; l <= b && i+l <= n; l++)
	{
		ans |= go(i + l, n - 1, k - 1, a, b, n, str);
		if (ans){
			dp[i][j][k] = l;
			dp1[i][j][k] = ans;
			return ans;
		}
	}
	dp1[i][j][k] = ans;
	return ans;
}

void solve()
{
	int k, a, b;
	cin >> k >> a >> b;
	string str;
	cin >> str;
	int n = str.length();
	for (int i = 0; i < n + 1; i++)
		for (int j = 0; j < n + 1; j++)
			for (int l = 0; l < k + 1; l++)
				dp[i][j][l] = dp1[i][j][l] = -1;
	bool ans = go(0, n - 1, k - 1, a, b, n, str);
	if (!ans)
		cout << "No solution" << ln;
	else
	{
		int i = 0, j = n - 1, l = k - 1;
		while (i <= j)
		{
			cout << str.substr(i, dp[i][j][l]) << ln;
			i = i + dp[i][j][l];
			l--;
		}
	}
	return;
}

int main()
{
	FASTIO;
#ifdef file_input
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	clock_t start, stop;
	int t = 1;
#ifdef multitest
	cin >> t;
#endif
#ifdef measure_time
	start = clock();
#endif
	for (int tc = 1; tc < t + 1; tc++)
		solve();
#ifdef measure_time
	stop = clock();
	cerr << "Time :" << fixed << setprecision(5) << double(stop - start) / double(CLOCKS_PER_SEC) << "s" << ln;
#endif
	return 0;
}


//Himanshu Shukla
#pragma GCC optimize("O2")
#include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0)
//#define file_input
//#define multitest
//#define measure_time
#define ll long long
#define v32 vector<int>
#define v64 vector<ll>
#define s32 set<int>
#define s64 set<ll>
#define graph vector<s32>
#define p32 pair<int, int>
#define p64 pair<ll, ll>
#define fi first
#define se second
#define ln '\n'
#define debug(x) cerr << (#x) << ": " << (x) << ln
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline ll add(ll a, ll b, ll m) { return (((a % m + b % m) % m + m) % m); }
inline ll mul(ll a, ll b, ll m) { return (((a % m * b % m) % m + m) % m); }
const double EPS = 1e-6;
const ll MOD = 1e9 + 7;
template <typename T, typename U>
ostream &operator<<(ostream &out, const pair<T, U> &p)
{
	out << '[' << p.fi << ", " << p.se << ']';
	return out;
}
template <template <typename, typename...> class ContainerType, typename ValueType, typename... Args>
void print_container(const ContainerType<ValueType, Args...> &c)
{
	cout << "{ ";
	for (const auto &v : c)
		cout << v << ' ';
	cout << '}' << ln;
}

int dp[305][305][305];
int dp1[305][305][305];

int go(int i, int j, int k, int a, int b, int n, string &str)
{
	if ((j - i + 1) >= a && (j - i + 1) <= b && k == 0)
	{
		dp[i][j][k] = (j - i + 1);
		dp1[i][j][k] = 1;
		return 1;
	}
	if (k == 0 && ((j - i + 1) < a || (j - i + 1) > b))
	{
		dp[i][j][k] = 0;
		dp1[i][j][k] = 0;
		return 0;
	}
	if (dp1[i][j][k] != -1)
		return dp1[i][j][k];
	int ans = 0;
	for (int l = a; l <= b; l++)
	{
		ans |= go(i + l, n - 1, k - 1, a, b, n, str);
		if (ans){
			dp[i][j][k] = l;
			dp1[i][j][k] = ans;
			return ans;
		}
	}
	dp1[i][j][k] = ans;
	return ans;
}

void solve()
{
	int k, a, b;
	cin >> k >> a >> b;
	string str;
	cin >> str;
	int n = str.length();
	for (int i = 0; i < n + 1; i++)
		for (int j = 0; j < n + 1; j++)
			for (int l = 0; l < k + 1; l++)
				dp[i][j][l] = dp1[i][j][l] = -1;
	bool ans = go(0, n - 1, k - 1, a, b, n, str);
	if (!ans)
		cout << "No solution" << ln;
	else
	{
		int i = 0, j = n - 1, l = k - 1;
		while (i <= j)
		{
			cout << str.substr(i, dp[i][j][l]) << ln;
			i = i + dp[i][j][l];
			l--;
		}
	}
	return;
}

int main()
{
	FASTIO;
#ifdef file_input
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	clock_t start, stop;
	int t = 1;
#ifdef multitest
	cin >> t;
#endif
#ifdef measure_time
	start = clock();
#endif
	for (int tc = 1; tc < t + 1; tc++)
		solve();
#ifdef measure_time
	stop = clock();
	cerr << "Time :" << fixed << setprecision(5) << double(stop - start) / double(CLOCKS_PER_SEC) << "s" << ln;
#endif
	return 0;
}


//Himanshu Shukla
#pragma GCC optimize("O2")
#include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0)
//#define file_input
//#define multitest
//#define measure_time
#define ll long long
#define v32 vector<int>
#define v64 vector<ll>
#define s32 set<int>
#define s64 set<ll>
#define graph vector<s32>
#define p32 pair<int, int>
#define p64 pair<ll, ll>
#define fi first
#define se second
#define ln '\n'
#define debug(x) cerr << (#x) << ": " << (x) << ln
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline ll add(ll a, ll b, ll m) { return (((a % m + b % m) % m + m) % m); }
inline ll mul(ll a, ll b, ll m) { return (((a % m * b % m) % m + m) % m); }
const double EPS = 1e-6;
const ll MOD = 1e9 + 7;
template <typename T, typename U>
ostream &operator<<(ostream &out, const pair<T, U> &p)
{
	out << '[' << p.fi << ", " << p.se << ']';
	return out;
}
template <template <typename, typename...> class ContainerType, typename ValueType, typename... Args>
void print_container(const ContainerType<ValueType, Args...> &c)
{
	cout << "{ ";
	for (const auto &v : c)
		cout << v << ' ';
	cout << '}' << ln;
}

int dp[205][205][205];
int dp1[205][205][205];

int go(int i, int j, int k, int a, int b, int n, string &str)
{
	if ((j - i + 1) >= a && (j - i + 1) <= b && k == 0)
	{
		dp[i][j][k] = (j - i + 1);
		dp1[i][j][k] = 1;
		return 1;
	}
	if (k == 0 && ((j - i + 1) < a || (j - i + 1) > b))
	{
		dp[i][j][k] = 0;
		dp1[i][j][k] = 0;
		return 0;
	}
	if (dp1[i][j][k] != -1)
		return dp1[i][j][k];
	int ans = 0;
	for (int l = a; l <= b; l++)
	{
		ans |= go(i + l, n - 1, k - 1, a, b, n, str);
		if (ans){
			dp[i][j][k] = l;
			dp1[i][j][k] = ans;
			return ans;
		}
	}
	dp1[i][j][k] = ans;
	return ans;
}

void solve()
{
	int k, a, b;
	cin >> k >> a >> b;
	string str;
	cin >> str;
	int n = str.length();
	for (int i = 0; i < n + 1; i++)
		for (int j = 0; j < n + 1; j++)
			for (int l = 0; l < k + 1; l++)
				dp[i][j][l] = dp1[i][j][l] = -1;
	bool ans = go(0, n - 1, k - 1, a, b, n, str);
	if (!ans)
		cout << "No Solution" << ln;
	else
	{
		int i = 0, j = n - 1, l = k - 1;
		while (i <= j)
		{
			cout << str.substr(i, dp[i][j][l]) << ln;
			i = i + dp[i][j][l];
			l--;
		}
	}
	return;
}

int main()
{
	FASTIO;
#ifdef file_input
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	clock_t start, stop;
	int t = 1;
#ifdef multitest
	cin >> t;
#endif
#ifdef measure_time
	start = clock();
#endif
	for (int tc = 1; tc < t + 1; tc++)
		solve();
#ifdef measure_time
	stop = clock();
	cerr << "Time :" << fixed << setprecision(5) << double(stop - start) / double(CLOCKS_PER_SEC) << "s" << ln;
#endif
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

// -----------------------------------------------------------------------------
//                              Quick and Dirty

template<typename T>
using vector2d=vector<vector<T>>;
template<typename T>
using pair2=pair<T, T>;

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
//                                   Debug

string to_string(string s)      { return '"' + s + '"';          }
string to_string(const char* s) { return to_string((string) s);  }
string to_string(bool b)        { return (b ? "true" : "false"); }

template <typename A, typename B>
string to_string(pair<A, B> p) {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for (const auto &x : v) {
        if (!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
    cerr << " " << to_string(H);
    debug_out(T...);
}

#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// -----------------------------------------------------------------------------

int k, a, b;
string s;
int n;
vector2d<pair2<int>> dp;

bool Solve(int length, int n_lines) {
    if (n_lines == 0) {
        return length == 0;
    }

    if (length <= 0) {
        return false;
    }

    for (int i = a; i <= b; i++) {
        if (Solve(length - i, n_lines - 1)) {
            dp[length][n_lines] = {length - i, n_lines - 1};
            return true;
        }
    }

    return false;
}

void Main() {
    cin >> k >> a >> b >> s;
    n = s.length();

    if (k * a > n || k * b < n) {
        cout << "No solution\n";
        return;
    }

    dp.resize(n + 1, vector<pair2<int>>(k + 1, {0, 0}));
    Solve(n, k);

    vector<int> res;
    int x = n;
    int y = k;

    while (true) {
        res.push_back(x);
        int nx = dp[x][y].first;
        int ny = dp[x][y].second;
        assert(ny == y - 1);
        x = nx;
        y = ny;
        if (x == 0 && y == 0) break;
    }

    reverse(res.begin(), res.end());

    int start = 0;

    for (int end : res) {
        for (int i = start; i < end; i++) {
            cout << s[i];
        }
        cout << '\n';
        start = end;
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    Main();
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

// -----------------------------------------------------------------------------
//                              Quick and Dirty

template<typename T>
using vector2d=vector<vector<T>>;
template<typename T>
using pair2=pair<T, T>;

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
//                                   Debug

string to_string(string s)      { return '"' + s + '"';          }
string to_string(const char* s) { return to_string((string) s);  }
string to_string(bool b)        { return (b ? "true" : "false"); }

template <typename A, typename B>
string to_string(pair<A, B> p) {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for (const auto &x : v) {
        if (!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
    cerr << " " << to_string(H);
    debug_out(T...);
}

#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// -----------------------------------------------------------------------------

int k, a, b;
string s;
int n;
vector2d<pair2<int>> dp;

bool Solve(int length, int n_lines) {
    if (dp[length][n_lines] == make_pair(-2, -2)) {
        return false;
    }

    if (dp[length][n_lines] != make_pair(-1, -1)) {
        return true;
    }

    if (n_lines == 0) {
        return length == 0;
    }

    if (length <= 0) {
        return false;
    }

    for (int i = a; i <= b; i++) {
        if (Solve(length - i, n_lines - 1)) {
            dp[length][n_lines] = {length - i, n_lines - 1};
            return true;
        }
    }

    dp[length][n_lines] = {-2, -2};
    return false;
}

void Main() {
    cin >> k >> a >> b >> s;
    n = s.length();

    if (k * a > n || k * b < n) {
        cout << "No solution\n";
        return;
    }

    dp.resize(n + 1, vector<pair2<int>>(k + 1, {-1, -1}));
    Solve(n, k);

    vector<int> res;
    int x = n;
    int y = k;

    while (true) {
        res.push_back(x);
        int nx = dp[x][y].first;
        int ny = dp[x][y].second;
        assert(ny == y - 1);
        x = nx;
        y = ny;
        if (x == 0 && y == 0) break;
    }

    reverse(res.begin(), res.end());

    int start = 0;

    for (int end : res) {
        for (int i = start; i < end; i++) {
            cout << s[i];
        }
        cout << '\n';
        start = end;
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    Main();
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

// -----------------------------------------------------------------------------
//                              Quick and Dirty

template<typename T>
using vector2d=vector<vector<T>>;
template<typename T>
using pair2=pair<T, T>;

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
//                                   Debug

string to_string(string s)      { return '"' + s + '"';          }
string to_string(const char* s) { return to_string((string) s);  }
string to_string(bool b)        { return (b ? "true" : "false"); }

template <typename A, typename B>
string to_string(pair<A, B> p) {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for (const auto &x : v) {
        if (!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
    cerr << " " << to_string(H);
    debug_out(T...);
}

#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// -----------------------------------------------------------------------------

int k, a, b;
string s;
int n;
vector2d<pair2<int>> dp;

bool Solve(int length, int n_lines) {
    if (dp[length][n_lines] != make_pair(-1, -1)) {
        debug(length, n_lines);
        return true;
    }

    if (n_lines == 0) {
        return length == 0;
    }

    if (length <= 0) {
        return false;
    }

    for (int i = a; i <= b; i++) {
        if (Solve(length - i, n_lines - 1)) {
            dp[length][n_lines] = {length - i, n_lines - 1};
            return true;
        }
    }

    dp[length][n_lines] = {-2, -2};
    return false;
}

void Main() {
    cin >> k >> a >> b >> s;
    n = s.length();

    if (k * a > n || k * b < n) {
        cout << "No solution\n";
        return;
    }

    dp.resize(n + 1, vector<pair2<int>>(k + 1, {-1, -1}));
    Solve(n, k);

    vector<int> res;
    int x = n;
    int y = k;

    while (true) {
        res.push_back(x);
        int nx = dp[x][y].first;
        int ny = dp[x][y].second;
        assert(ny == y - 1);
        x = nx;
        y = ny;
        if (x == 0 && y == 0) break;
    }

    reverse(res.begin(), res.end());

    int start = 0;

    for (int end : res) {
        for (int i = start; i < end; i++) {
            cout << s[i];
        }
        cout << '\n';
        start = end;
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    Main();
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

// -----------------------------------------------------------------------------
//                              Quick and Dirty

template<typename T>
using vector2d=vector<vector<T>>;
template<typename T>
using pair2=pair<T, T>;

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
//                                   Debug

string to_string(string s)      { return '"' + s + '"';          }
string to_string(const char* s) { return to_string((string) s);  }
string to_string(bool b)        { return (b ? "true" : "false"); }

template <typename A, typename B>
string to_string(pair<A, B> p) {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for (const auto &x : v) {
        if (!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
    cerr << " " << to_string(H);
    debug_out(T...);
}

#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// -----------------------------------------------------------------------------

int k, a, b;
string s;
int n;
vector2d<pair2<int>> dp;

bool Solve(int length, int n_lines) {
    if (dp[length][n_lines] != make_pair(-1, -1)) {
        return true;
    }

    if (n_lines == 0) {
        return length == 0;
    }

    if (length <= 0) {
        return false;
    }

    for (int i = a; i <= b; i++) {
        if (Solve(length - i, n_lines - 1)) {
            dp[length][n_lines] = {length - i, n_lines - 1};
            return true;
        }
    }

    return false;
}

void Main() {
    cin >> k >> a >> b >> s;
    n = s.length();

    if (k * a > n || k * b < n) {
        cout << "No solution\n";
        return;
    }

    dp.resize(n + 1, vector<pair2<int>>(k + 1, {-1, -1}));
    Solve(n, k);

    vector<int> res;
    int x = n;
    int y = k;

    while (true) {
        res.push_back(x);
        int nx = dp[x][y].first;
        int ny = dp[x][y].second;
        assert(ny == y - 1);
        x = nx;
        y = ny;
        if (x == 0 && y == 0) break;
    }

    reverse(res.begin(), res.end());

    int start = 0;

    for (int end : res) {
        for (int i = start; i < end; i++) {
            cout << s[i];
        }
        cout << '\n';
        start = end;
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    Main();
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

// -----------------------------------------------------------------------------
//                              Quick and Dirty

template<typename T>
using vector2d=vector<vector<T>>;
template<typename T>
using pair2=pair<T, T>;

// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
//                                   Debug

string to_string(string s)      { return '"' + s + '"';          }
string to_string(const char* s) { return to_string((string) s);  }
string to_string(bool b)        { return (b ? "true" : "false"); }

template <typename A, typename B>
string to_string(pair<A, B> p) {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename A>
string to_string(A v) {
    bool first = true;
    string res = "{";
    for (const auto &x : v) {
        if (!first) {
            res += ", ";
        }
        first = false;
        res += to_string(x);
    }
    res += "}";
    return res;
}

void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
    cerr << " " << to_string(H);
    debug_out(T...);
}

#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// -----------------------------------------------------------------------------

int k, a, b;
string s;
int n;
vector2d<pair2<int>> dp;

bool Solve(int length, int n_lines) {
    if (dp[length][n_lines] != make_pair(-1, -1)) {
        debug(length, n_lines);
        return true;
    }

    if (n_lines == 0) {
        return length == 0;
    }

    if (length <= 0) {
        return false;
    }

    for (int i = a; i <= b; i++) {
        if (Solve(length - i, n_lines - 1)) {
            dp[length][n_lines] = {length - i, n_lines - 1};
            return true;
        }
        else {
            dp[length][n_lines] = {-2, -2};
        }
    }

    return false;
}

void Main() {
    cin >> k >> a >> b >> s;
    n = s.length();

    if (k * a > n || k * b < n) {
        cout << "No solution\n";
        return;
    }

    dp.resize(n + 1, vector<pair2<int>>(k + 1, {-1, -1}));
    Solve(n, k);

    vector<int> res;
    int x = n;
    int y = k;

    while (true) {
        res.push_back(x);
        int nx = dp[x][y].first;
        int ny = dp[x][y].second;
        assert(ny == y - 1);
        x = nx;
        y = ny;
        if (x == 0 && y == 0) break;
    }

    reverse(res.begin(), res.end());

    int start = 0;

    for (int end : res) {
        for (int i = start; i < end; i++) {
            cout << s[i];
        }
        cout << '\n';
        start = end;
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    Main();
    return 0;
}


#include <bits/stdc++.h>
typedef long long ll;
using namespace std;

int dp[205][205];
int a, b;

int calc(int k, int pos)
{
	if (k < 0 || k*b<pos)
		return -1;
	if (k == 1)
	{
		if (pos+1>=a && pos+1<=b)
			return pos;
		else
			return -1;
	}
	auto& res = dp[k][pos];
	if (res != -1)
		return res;
	for (int i = a; i <= b; i++)
	{
		int tmp = calc(k - 1, pos - i);
		if (tmp != -1)
		{
			res = pos - i;
			break;
		}
	}
	return res;
}
int main()
{
	memset(dp, -1, sizeof dp);
	int k;
	cin >> k >> a >> b;
	string str;
	cin >> str;
	int prev = str.size();
	int init = calc(k, str.size() - 1);
	vector<string> result;
	if (init != -1)
	{
		while (1)
		{
			string prt;
			for (int i = init; i < prev; i++)
				prt += str[i];
			result.push_back(prt);
			if (k - 1 >= 0)
			{
				int temp = init;
				init = calc(--k, prev-prt.size());
				if (k == 1)
					init = 0;
				prev = temp;
			}
			else
				break;
			if (k == 0)
				break;
		}
		reverse(result.begin(), result.end());
		for (auto elem : result)
			cout << elem << endl;
	}
	else
	{
		cout << "No solution" << endl;
	}
}


#include <bits/stdc++.h>
typedef long long ll;
using namespace std;

int dp[205][205];
int a, b;

int calc(int k, int pos)
{
	if (k < 0 || k*b<pos)
		return -1;
	if (k == 1)
	{
		if (pos+1>=a && pos+1<=b)
			return pos;
		else
			return -1;
	}
	auto& res = dp[k][pos];
	if (res != -1)
		return res;
	for (int i = a; i <= b; i++)
	{
		int tmp = calc(k - 1, pos - i);
		if (tmp != -1)
		{
			res = pos - i;
			break;
		}
	}
	return res;
}
int main()
{
	memset(dp, -1, sizeof dp);
	int k;
	cin >> k >> a >> b;
	string str;
	cin >> str;
	int prev = str.size();
	int init = calc(k, str.size() - 1);
	vector<string> result;
	if (init != -1)
	{
		while (1)
		{
			string prt;
			for (int i = init; i < prev; i++)
				prt += str[i];
			result.push_back(prt);
			if (k - 1 >= 0)
			{
				int temp = init;
				init = calc(--k, prev-prt.size());
				if (k == 1)
					init = 0;
				prev = temp;
			}
			else
				break;
			if (k == 0)
				break;
		}
		reverse(result.begin(), result.end());
		for (auto elem : result)
			cout << elem << endl;
	}
	else
	{
		cout << "No solutiuon" << endl;
	}
}


#include <bits/stdc++.h>
typedef long long ll;
using namespace std;

int dp[205][205];
int a, b;

int calc(int k, int pos)
{
	if (k < 0 || k*b<pos || k>pos+1)
		return -1;
	if (k == 1)
	{
		if (pos+1>=a && pos+1<=b)
			return pos;
		else
			return -1;
	}
	auto& res = dp[k][pos];
	if (res != -1)
		return res;
	for (int i = a; i <= b; i++)
	{
		int tmp = calc(k - 1, pos - i);
		if (tmp != -1)
		{
			res = pos - i;
			break;
		}
	}
	return res;
}
int main()
{
	memset(dp, -1, sizeof dp);
	int k;
	cin >> k >> a >> b;
	string str;
	cin >> str;
	int prev = str.size()-1;
	int init = calc(k, str.size() - 1);
	vector<string> result;
	if (init != -1)
	{
		while (1)
		{
			string prt;
			int i = init + 1;
			if (k == 1)
				i = 0;
			for (; i <= prev; i++)
				prt += str[i];
			result.push_back(prt);
			if (k - 1 >= 0)
			{
				int temp = init;
				init = calc(--k, prev-prt.size());
				if (k == 1)
					init = 0;
				prev = temp;
			}
			else
				break;
			if (k == 0)
				break;
		}
		reverse(result.begin(), result.end());
		for (auto elem : result)
			cout << elem << endl;
	}
	else
	{
		cout << "No solution" << endl;
	}
}


#include <bits/stdc++.h>
typedef long long ll;
using namespace std;

int dp[205][205];
int a, b;

int calc(int k, int pos)
{
	if (k < 0 || k*b<pos)
		return -1;
	if (k == 1)
	{
		if (pos+1>=a && pos+1<=b)
			return pos;
		else
			return -1;
	}
	auto& res = dp[k][pos];
	if (res != -1)
		return res;
	for (int i = a; i <= b; i++)
	{
		int tmp = calc(k - 1, pos - i);
		if (tmp != -1)
		{
			res = pos - i;
			break;
		}
	}
	return res;
}
int main()
{
	memset(dp, -1, sizeof dp);
	int k;
	cin >> k >> a >> b;
	string str;
	cin >> str;
	int prev = str.size()-1;
	int init = calc(k, str.size() - 1);
	vector<string> result;
	if (init != -1)
	{
		while (1)
		{
			string prt;
			int i = init + 1;
			if (k == 1)
				i = 0;
			for (; i <= prev; i++)
				prt += str[i];
			result.push_back(prt);
			if (k - 1 >= 0)
			{
				int temp = init;
				init = calc(--k, prev-prt.size());
				if (k == 1)
					init = 0;
				prev = temp;
			}
			else
				break;
			if (k == 0)
				break;
		}
		reverse(result.begin(), result.end());
		for (auto elem : result)
			cout << elem << endl;
	}
	else
	{
		cout << "No solution" << endl;
	}
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define nl cout<<'\n'
//int dp[k][a][]
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    ll n,a,b;
    cin>>n>>a>>b;
    string s;
    cin>>s;
    int l=s.length();
    if(l<(a*n) || l>(b*n))
    {
        cout<<"No Solution";
        return 0;
    }
    int len=a;
    while((n*len)<l)
    len++;
    if(l%len==0)
    {
        for(int i=0;i<l;i++)
        {
            cout<<s[i];
            if((i+1)%len==0)
            nl;
        }
        return 0;
    }
    int i;
    for( i=1;i<=200;i++)
    {
        if((l-(len-1)*i)%len==0)
        break;
    }
    int counter=0;
    for(int j=0;j<i;j++)
    {
        for(int x=0;x<len-1;x++)
        cout<<s[counter++];
        nl;
    }
    for(int j=0;j<(l-(len-1)*i)/len;j++)
    {
        for(int x=0;x<len;x++)
        cout<<s[counter++];
        nl;
    }

}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define nl cout<<'\n'
//int dp[k][a][]
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    ll n,a,b;
    cin>>n>>a>>b;
    string s;
    cin>>s;
    int l=s.length();
    if(l<(a*n) || l>(b*n))
    {
        cout<<"No solution";
        return 0;
    }
    int len=a;
    while((n*len)<l)
    len++;
    if(l%len==0)
    {
        for(int i=0;i<l;i++)
        {
            cout<<s[i];
            if((i+1)%len==0)
            nl;
        }
        return 0;
    }
    int i;
    for( i=1;i<=200;i++)
    {
        if((l-(len-1)*i)%len==0 && (l-(len-1)*i)/len==(n-i))
        break;
    }
    int counter=0;
    for(int j=0;j<i;j++)
    {
        for(int x=0;x<len-1;x++)
        cout<<s[counter++];
        nl;
    }
    for(int j=0;j<(l-(len-1)*i)/len;j++)
    {
        for(int x=0;x<len;x++)
        cout<<s[counter++];
        nl;
    }

}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define nl cout<<'\n'
//int dp[k][a][]
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    ll n,a,b;
    cin>>n>>a>>b;
    string s;
    cin>>s;
    int l=s.length();
    if(l<(a*n) || l>(b*n))
    {
        cout<<"No solution";
        return 0;
    }
    int len=a;
    while((n*len)<l)
    len++;
    if(l%len==0 && l/len==n)
    {
        for(int i=0;i<l;i++)
        {
            cout<<s[i];
            if((i+1)%len==0)
            nl;
        }
        return 0;
    }
    int i;
    for( i=1;i<=200;i++)
    {
        if((l-(len-1)*i)%len==0 && (l-(len-1)*i)/len==(n-i))
        break;
    }
    int counter=0;
    for(int j=0;j<i;j++)
    {
        for(int x=0;x<len-1;x++)
        cout<<s[counter++];
        nl;
    }
    for(int j=0;j<(l-(len-1)*i)/len;j++)
    {
        for(int x=0;x<len;x++)
        cout<<s[counter++];
        nl;
    }

}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define nl cout<<'\n'
//int dp[k][a][]
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    ll n,a,b;
    cin>>n>>a>>b;
    string s;
    cin>>s;
    int l=s.length();
    if(l<(a*n) || l>(b*n))
    {
        cout<<"No solution";
        return 0;
    }
    int len=a;
    while((n*len)<l)
    len++;
    if(l%len==0)
    {
        for(int i=0;i<l;i++)
        {
            cout<<s[i];
            if((i+1)%len==0)
            nl;
        }
        return 0;
    }
    int i;
    for( i=1;i<=200;i++)
    {
        if((l-(len-1)*i)%len==0)
        break;
    }
    int counter=0;
    for(int j=0;j<i;j++)
    {
        for(int x=0;x<len-1;x++)
        cout<<s[counter++];
        nl;
    }
    for(int j=0;j<(l-(len-1)*i)/len;j++)
    {
        for(int x=0;x<len;x++)
        cout<<s[counter++];
        nl;
    }

}


#include<bits/stdc++.h>
using namespace std;

#define sup ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)

int main()
{
	sup;

    int k, a, b;
    cin >> k >> a >> b;

    string s;
    cin >> s;

    int n = s.length();

    if((n + k - 1) / k > b || (n / k) < a)
        cout << "No solution" << endl;
    else {
        int avg = n / k;
        int extras = n - (avg * k);
        int next = 0;
        for(int i = 0; i < k; i++) {
            if(extras > 0) {
                cout << s.substr(next, avg + 1) << endl;
                next += avg + 1;
                extras--;
            }
            else {
                cout << s.substr(next, avg) << endl;
                next += avg;
            }
        }
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

#define sup ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)

int main()
{
	sup;

    int k, a, b;
    cin >> k >> a >> b;

    string s;
    cin >> s;

    int n = s.length();

    if((n + k - 1) / k > b || (n / k) < a)
        cout << "No solution" << endl;
    else {
        vector<vector<bool>> dp(n, vector<bool> (n, false));
        dp[0][0] = true;
        for(int i = 1; i < n; i++) {
            for(int j = 1; j < k; j++) {
                for(int p = a; p <= b; p++) {
                    if(p > i)
                        break;
                    if(dp[i - p][j - 1])
                        dp[i][j] = true;
                }
            }
        }

        vector<string> ans;

        int i = n, j = k;

        while(i && j) {
            for(int p = a; p <= b; p++) {
                if(dp[i - p][j - 1]) {
                    ans.push_back(s.substr(i - p, p));
                    i = i - p;
                    j--;
                    break;
                }
            }
        }

        for(int i = ans.size() - 1; i >= 0; i--) {
            cout << ans[i] << endl;
        }
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

#define sup ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)

int main()
{
	sup;

    int k, a, b;
    cin >> k >> a >> b;

    string s;
    cin >> s;

    int n = s.length();

    if((n + k - 1) / k > b || (n / k) < a)
        cout << "No solution" << endl;
    else {
        int avg = n / k;
        int extras = n - (avg * k);
        int next = 0;
        for(int i = 0; i < 3; i++) {
            if(extras > 0) {
                cout << s.substr(next, avg + 1) << endl;
                next += avg + 1;
                extras--;
            }
            else {
                cout << s.substr(next, avg) << endl;
                next += avg;
            }
        }
    }

    return 0;
}


#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#define l(i,a,b) for(auto i=a;i<b;i++)
#define lr(i,a,b) for(auto i=a;i>=b;i--)
#define ll long long
#define lli long long int
#define ld long double
#define vec vector<int>
#define mii map<ll,ll>
#define vl vector<long long>
#define se set <long long int>
#define pi pair<long long,long long>
#define pb push_back
#define mp make_pair
#define ft first
#define sd second
#define all(v) v.begin(), v.end()
#define in(x) cin>>x
#define o(x) cout<<x
#define SYNC ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define PI 3.14159265359
using namespace std;

ll modulo(ll a, ll b, ll n){
    long long x=1, y=a;
    while (b > 0) {
        if (b%2 == 1) {
            x = (x*y) % n;
        }
        y = (y*y) % n;
        b /= 2;
    }
    return x % n;
}

int main()
{
    SYNC
    //freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
    ll k,a,b; in(k)>>a>>b;
    string s; in(s);
    ll n=s.size();
    if(k*a > n || k*b < n)
    {
        o("No solution")<<endl;
        return 0;
    }
    ll p;
    if(n%k==0)
    p=n/k;
    else
    p=(n/k)+1;
    for(ll i=0; i<n; i+=p)
    {
        for(ll j=0; j<p; j++)
        {
            if(i+j>n-1)
            {
                return 0;
            }
            o(s[i+j]);
        }
        o(endl);
    }

}


#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#define l(i,a,b) for(auto i=a;i<b;i++)
#define lr(i,a,b) for(auto i=a;i>=b;i--)
#define ll long long
#define lli long long int
#define ld long double
#define vec vector<int>
#define mii map<ll,ll>
#define vl vector<long long>
#define se set <long long int>
#define pi pair<long long,long long>
#define pb push_back
#define mp make_pair
#define ft first
#define sd second
#define all(v) v.begin(), v.end()
#define in(x) cin>>x
#define o(x) cout<<x
#define SYNC ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define PI 3.14159265359
using namespace std;

ll modulo(ll a, ll b, ll n){
    long long x=1, y=a;
    while (b > 0) {
        if (b%2 == 1) {
            x = (x*y) % n;
        }
        y = (y*y) % n;
        b /= 2;
    }
    return x % n;
}

int main()
{
    SYNC
    //freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
    ll k,a,b; in(k)>>a>>b;
    string s; in(s);
    ll n=s.size();
    if(k*a > n || k*b < n)
    {
        o("No solution")<<endl;
        return 0;
    }
    ll p;
    if(n%k==0)
    p=n/k;
    else
    p=(n/k)+1;
    for(ll i=0; i<n; i+=p)
    {
        for(ll j=0; j<p; j++)
        {
            o(s[i+j]);
        }
        o(endl);
    }

}


#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#define l(i,a,b) for(auto i=a;i<b;i++)
#define lr(i,a,b) for(auto i=a;i>=b;i--)
#define ll long long
#define lli long long int
#define ld long double
#define vec vector<int>
#define mii map<ll,ll>
#define vl vector<long long>
#define se set <long long int>
#define pi pair<long long,long long>
#define pb push_back
#define mp make_pair
#define ft first
#define sd second
#define all(v) v.begin(), v.end()
#define in(x) cin>>x
#define o(x) cout<<x
#define SYNC ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define PI 3.14159265359
using namespace std;

ll modulo(ll a, ll b, ll n){
    long long x=1, y=a;
    while (b > 0) {
        if (b%2 == 1) {
            x = (x*y) % n;
        }
        y = (y*y) % n;
        b /= 2;
    }
    return x % n;
}

int main()
{
    SYNC
    //freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
    ll k,a,b; in(k)>>a>>b;
    string s; in(s);
    ll n=s.size();
    if(k*a > n || k*b < n)
    {
        o("No solution")<<endl;
        return 0;
    }
    ll rem=n-(k*a);
    ll i=0;
    for(ll p=0; p<k; p++)
    {
        for(ll j=0; j<a; j++,i++)
        o(s[i]);
        for(ll j=0; j<(b-a); j++,rem--,i++)
        {
            if(!rem)
            break;
            o(s[i]);
        }
        o(endl);
    }

}


//#pragma GCC optimize("03", "unroll-loops")
//#pragma GCC target("avx2")

#include <bits/stdc++.h>

#define fast() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define FOR(i,n) for(i=0;i<n;i++)
#define FORn(i,j,n) for(i=j;i<n;i++)
#define pb push_back
#define unique_sort(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define vli vector<lli>
#define vi vector<int>
#define vs vector<string>
#define vprint(v) for(auto t:v)cout<<t<<" "
#define endl "\n"

typedef long long int lli;
typedef long int li;

const lli mod=1000000007;
const lli limit=1000000;

using namespace std;

void fc(lli &x)
    {
        bool neg=false;
        register char c;
        x =0;
        c=getchar();
        if(c=='-')
        {
            neg = true;
            c=getchar();
        }
        for(;(c>47 && c<58);c=getchar())
            x = (x<<1) + (x<<3) +c -48;
        if(neg)
            x *=-1;
    }

int main() {

    fast()
    lli n,q,t;
    lli temp,temp1,temp2,temp3;
    lli i,j,k;
    lli a,b;
    string s;
    cin>>k>>a>>b;
    cin>>s;
    if((k*b)<s.length() || (k*a)>s.length()){
        cout<<"No solution"<<endl;
        exit(0);
    }
    temp=s.length()%k;
    temp1=s.length()/k;
    temp2=0;
    string ans;
    FOR(i,k){
        temp3=min(b-temp1,temp);
        temp-=temp3;
        ans="";
        for(j=temp2;j<(temp2+temp1+temp3);j++)ans+=s[j];
        cout<<ans<<endl;
        temp2+=temp1+temp3;
    }

}


//#pragma GCC optimize("03", "unroll-loops")
//#pragma GCC target("avx2")

#include <bits/stdc++.h>

#define fast() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define FOR(i,n) for(i=0;i<n;i++)
#define FORn(i,j,n) for(i=j;i<n;i++)
#define pb push_back
#define unique_sort(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define vli vector<lli>
#define vi vector<int>
#define vs vector<string>
#define vprint(v) for(auto t:v)cout<<t<<" "
#define endl "\n"

typedef long long int lli;
typedef long int li;

const lli mod=1000000007;
const lli limit=1000000;

using namespace std;

void fc(lli &x)
    {
        bool neg=false;
        register char c;
        x =0;
        c=getchar();
        if(c=='-')
        {
            neg = true;
            c=getchar();
        }
        for(;(c>47 && c<58);c=getchar())
            x = (x<<1) + (x<<3) +c -48;
        if(neg)
            x *=-1;
    }

int main() {

    fast()
    lli n,q,t;
    lli temp,temp1,temp2,temp3;
    lli i,j,k;
    lli a,b;
    string s;
    cin>>k>>a>>b;
    cin>>s;
    if((k*b)<s.length() || (k*a)>s.length()){
        cout<<"No solution"<<endl;
        exit(0);
    }
    temp=b-a+1;
    lli value[temp+1],arr[s.length()+1][temp+1];
    memset(arr,0,sizeof(arr));
    for(i=0;i<temp;i++){
        value[i+1]=a+i;
        arr[0][i]=INT_MAX;
    }
    arr[0][temp]=INT_MAX;
    for(i=0;i<s.length()+1;i++){
        arr[i][0]=INT_MAX;
    }

    for(i=1;i<=(b-a+1);i++){
        //cout<<value[i]<<endl;
        for(j=1;j<=s.length();j++){
            if(value[i]==j)arr[j][i]=1;
            else if(j<value[i])arr[j][i]=arr[j][i-1];
            else{
                arr[j][i]=min(arr[j][i-1],arr[j-value[i]][i]+1);
            }
            //cout<<arr[j][i]<<" ";
        }
        //cout<<endl;
    }
    temp1=s.length();
    for(i=1;i<=(b-a+1);i++){
        //cout<<arr[temp1][i]<<endl;
        if(arr[temp1][i]==k)break;
    }
    vli v;
    if(i!=(b-a+2)){
        temp=s.length();
        while(temp){
            if(arr[temp][i]==arr[temp][i-1]){
                i--;
                continue;
            }
            temp1=value[i];
            v.pb(temp1);
            temp-=temp1;
        }
    }
    else{
        cout<<"No solution"<<endl;
        exit(0);
    }
    temp=0;
    string str;
    for(i=0;i<v.size();i++){
        str="";
        for(j=0;j<v[i];j++){
            str+=s[temp+j];
        }
        temp+=v[i];
        cout<<str<<endl;
    }

}


//#pragma GCC optimize("03", "unroll-loops")
//#pragma GCC target("avx2")

#include <bits/stdc++.h>

#define fast() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define FOR(i,n) for(i=0;i<n;i++)
#define FORn(i,j,n) for(i=j;i<n;i++)
#define pb push_back
#define unique_sort(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define vli vector<lli>
#define vi vector<int>
#define vs vector<string>
#define vprint(v) for(auto t:v)cout<<t<<" "
#define endl "\n"

typedef long long int lli;
typedef long int li;

const lli mod=1000000007;
const lli limit=1000000;

using namespace std;

void fc(lli &x)
    {
        bool neg=false;
        register char c;
        x =0;
        c=getchar();
        if(c=='-')
        {
            neg = true;
            c=getchar();
        }
        for(;(c>47 && c<58);c=getchar())
            x = (x<<1) + (x<<3) +c -48;
        if(neg)
            x *=-1;
    }

int main() {

    fast()
    lli n,q,t;
    lli temp,temp1,temp2,temp3;
    lli i,j,k;
    lli a,b;
    string s;
    cin>>k>>a>>b;
    cin>>s;
    if((k*b)<s.length() || (k*a)>s.length()){
        cout<<"No solution"<<endl;
        exit(0);
    }
    temp=b-a+1;
    lli value[temp+1],arr[s.length()+1][temp+1];
    memset(arr,0,sizeof(arr));
    for(i=0;i<temp;i++){
        value[i+1]=a+i;
        arr[0][i]=INT_MAX;
    }
    arr[0][temp]=INT_MAX;
    for(i=0;i<s.length()+1;i++){
        arr[i][0]=INT_MAX;
    }

    for(i=1;i<=(b-a+1);i++){
        //cout<<value[i]<<endl;
        for(j=1;j<=s.length();j++){
            if(value[i]==j)arr[j][i]=1;
            else if(j<value[i])arr[j][i]=arr[j][i-1];
            else{
                arr[j][i]=min(arr[j][i-1],arr[j-value[i]][i]+1);
            }
            //cout<<arr[j][i]<<" ";
        }
        //cout<<endl;
    }
    temp1=s.length();
    for(i=1;i<=(b-a+1);i++){
        //cout<<arr[temp1][i]<<endl;
        if(arr[temp1][i]==k)break;
    }
    vli v;
    if(i!=(b-a+2)){
        temp=s.length();
        while(temp>0){
            if(i==0)break;
            if(arr[temp][i]==arr[temp][i-1]){
                i--;
                continue;
            }
            temp1=value[i];
            v.pb(temp1);
            temp-=temp1;
        }
    }
    else{
        if(arr[s.length()][b-a+1]<k){
            i=b-a+1;
            temp=s.length();
            while(temp>0){
                if(i==0)break;
                if(arr[temp][i]==arr[temp][i-1]){
                    i--;
                    continue;
                }
                temp1=value[i];
                v.pb(temp1);
                temp-=temp1;
                //cout<<temp1<<endl;
            }
        }
        else {
            cout<<"No solution"<<endl;
            exit(0);
        }
    }
    //cout<<v.size()<<endl;
    if(v.size()<k){
        temp1=0;

        for(i=0;i<v.size();i++){
            if(temp1>=a)break;
            if((v[i]-a)>0){
                temp1+=v[i]-a;
                v[i]=a;
            }
            if(temp1>b){
                v[i]=v[i]-a+b-temp1;
                temp1=b;
            }
        }
        if(temp1<a){
            cout<<"No solution"<<endl;
            exit(0);
        }
        else{
            v.pb(temp1);

        }
    }
    sort(v.begin(),v.end(),greater<lli>());
    temp=0;
    string str;
    //vprint(v);
    //cout<<endl;
    for(i=0;i<v.size();i++){
        str="";
        //cout<<v[i]<<endl;
        for(j=0;j<v[i];j++){
            str+=s[temp+j];
        }
        temp+=v[i];
        cout<<str<<endl;
    }

}


//#pragma GCC optimize("03", "unroll-loops")
//#pragma GCC target("avx2")

#include <bits/stdc++.h>

#define fast() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define FOR(i,n) for(i=0;i<n;i++)
#define FORn(i,j,n) for(i=j;i<n;i++)
#define pb push_back
#define unique_sort(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define vli vector<lli>
#define vi vector<int>
#define vs vector<string>
#define vprint(v) for(auto t:v)cout<<t<<" "
#define endl "\n"

typedef long long int lli;
typedef long int li;

const lli mod=1000000007;
const lli limit=1000000;

using namespace std;

void fc(lli &x)
    {
        bool neg=false;
        register char c;
        x =0;
        c=getchar();
        if(c=='-')
        {
            neg = true;
            c=getchar();
        }
        for(;(c>47 && c<58);c=getchar())
            x = (x<<1) + (x<<3) +c -48;
        if(neg)
            x *=-1;
    }

int main() {

    fast()
    lli n,q,t;
    lli temp,temp1,temp2,temp3;
    lli i,j,k;
    lli a,b;
    string s;
    cin>>k>>a>>b;
    cin>>s;
    if((k*b)<s.length() || (k*a)>s.length()){
        cout<<"No solution"<<endl;
        exit(0);
    }
    temp=b-a+1;
    lli value[temp+1],arr[s.length()+1][temp+1];
    memset(arr,0,sizeof(arr));
    for(i=0;i<temp;i++){
        value[i+1]=a+i;
        arr[0][i]=INT_MAX;
    }
    arr[0][temp]=INT_MAX;
    for(i=0;i<s.length()+1;i++){
        arr[i][0]=INT_MAX;
    }

    for(i=1;i<=(b-a+1);i++){
        //cout<<value[i]<<endl;
        for(j=1;j<=s.length();j++){
            if(value[i]==j)arr[j][i]=1;
            else if(j<value[i])arr[j][i]=arr[j][i-1];
            else{
                arr[j][i]=min(arr[j][i-1],arr[j-value[i]][i]+1);
            }
            //cout<<arr[j][i]<<" ";
        }
        //cout<<endl;
    }
    temp1=s.length();
    for(i=1;i<=(b-a+1);i++){
        //cout<<arr[temp1][i]<<endl;
        if(arr[temp1][i]==k)break;
    }
    vli v;
    if(i!=(b-a+2)){
        temp=s.length();
        while(temp>0){
            if(i==0)break;
            if(arr[temp][i]==arr[temp][i-1]){
                i--;
                continue;
            }
            temp1=value[i];
            v.pb(temp1);
            temp-=temp1;
        }
    }
    else{
        if(arr[s.length()][b-a+1]<k){
            i=b-a+1;
            temp=s.length();
            while(temp>0){
                if(i==0)break;
                if(arr[temp][i]==arr[temp][i-1]){
                    i--;
                    continue;
                }
                temp1=value[i];
                v.pb(temp1);
                temp-=temp1;
                //cout<<temp1<<endl;
            }
        }
        else {
            cout<<"No solution"<<endl;
            exit(0);
        }
    }
    //cout<<v.size()<<endl;
    if(v.size()<k){
        vli v1;
        temp1=0;

        for(i=0;i<v.size();i++){
            if(temp1>=a)break;
            if((v[i]-a)>0){
                temp1+=v[i]-a;
                v[i]=a;
            }
            if(temp1>b){
                v[i]=v[i]-a+b-temp1;
                temp1=b;
            }
            v1.pb(v[i]);
        }
        if(temp1<a){
            cout<<"No solution"<<endl;
            exit(0);
        }
        else{
            v1.pb(temp1);
            for(j=i;j<v.size();j++){
                v1.pb(v[j]);
            }
            v=v1;
        }
    }
    temp=0;
    string str;
    //vprint(v);
    //cout<<endl;
    for(i=0;i<v.size();i++){
        str="";
        //cout<<v[i]<<endl;
        for(j=0;j<v[i];j++){
            str+=s[temp+j];
        }
        temp+=v[i];
        cout<<str<<endl;
    }

}


//#pragma GCC optimize("03", "unroll-loops")
//#pragma GCC target("avx2")

#include <bits/stdc++.h>

#define fast() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define FOR(i,n) for(i=0;i<n;i++)
#define FORn(i,j,n) for(i=j;i<n;i++)
#define pb push_back
#define unique_sort(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define vli vector<lli>
#define vi vector<int>
#define vs vector<string>
#define vprint(v) for(auto t:v)cout<<t<<" "
#define endl "\n"

typedef long long int lli;
typedef long int li;

const lli mod=1000000007;
const lli limit=1000000;

using namespace std;

void fc(lli &x)
    {
        bool neg=false;
        register char c;
        x =0;
        c=getchar();
        if(c=='-')
        {
            neg = true;
            c=getchar();
        }
        for(;(c>47 && c<58);c=getchar())
            x = (x<<1) + (x<<3) +c -48;
        if(neg)
            x *=-1;
    }

int main() {

    fast()
    lli n,q,t;
    lli temp,temp1,temp2,temp3;
    lli i,j,k;
    lli a,b;
    string s;
    cin>>k>>a>>b;
    cin>>s;
    if((k*b)<s.length() || (k*a)>s.length()){
        cout<<"No solution"<<endl;
        exit(0);
    }
    temp=b-a+1;
    lli value[temp+1],arr[s.length()+1][temp+1];
    memset(arr,0,sizeof(arr));
    for(i=0;i<temp;i++){
        value[i+1]=a+i;
        arr[0][i]=INT_MAX;
    }
    arr[0][temp]=INT_MAX;
    for(i=0;i<s.length()+1;i++){
        arr[i][0]=INT_MAX;
    }

    for(i=1;i<=(b-a+1);i++){
        //cout<<value[i]<<endl;
        for(j=1;j<=s.length();j++){
            if(value[i]==j)arr[j][i]=1;
            else if(j<value[i])arr[j][i]=arr[j][i-1];
            else{
                arr[j][i]=min(arr[j][i-1],arr[j-value[i]][i]+1);
            }
            //cout<<arr[j][i]<<" ";
        }
        //cout<<endl;
    }
    temp1=s.length();
    for(i=1;i<=(b-a+1);i++){
        //cout<<arr[temp1][i]<<endl;
        if(arr[temp1][i]==k)break;
    }
    vli v;
    if(i!=(b-a+2)){
        temp=s.length();
        while(temp>0){
            if(i==0)break;
            if(arr[temp][i]==arr[temp][i-1]){
                i--;
                continue;
            }
            temp1=value[i];
            v.pb(temp1);
            temp-=temp1;
        }
    }
    else{
        if(arr[s.length()][b-a+1]<k){
            i=b-a+1;
            temp=s.length();
            while(temp>0){
                if(i==0)break;
                if(arr[temp][i]==arr[temp][i-1]){
                    i--;
                    continue;
                }
                temp1=value[i];
                v.pb(temp1);
                temp-=temp1;
                //cout<<temp1<<endl;
            }
        }
        else {
            cout<<"No solution"<<endl;
            exit(0);
        }
    }
    //cout<<v.size()<<endl;
    if(v.size()<k){
        temp1=0;

        for(i=0;i<v.size();i++){
            if(temp1>=a)break;
            if((v[i]-a)>0){
                temp1+=v[i]-a;
                v[i]=a;
            }
            if(temp1>b){
                v[i]=v[i]-a+b-temp1;
                temp1=b;
            }
        }
        if(temp1<a){
            cout<<"No solution"<<endl;
            exit(0);
        }
        else{
            v.pb(temp1);

        }
    }
    temp=0;
    string str;
    //vprint(v);
    //cout<<endl;
    for(i=0;i<v.size();i++){
        str="";
        //cout<<v[i]<<endl;
        for(j=0;j<v[i];j++){
            str+=s[temp+j];
        }
        temp+=v[i];
        cout<<str<<endl;
    }

}


#include<bits/stdc++.h>
using namespace std;
#define int long long
#define die(x) return cout << x << endl, 0
#define all(o) o.begin(), o.end()
#define endl '\n'
#define IOS ios::sync_with_stdio(0), cin.tie(0)
#define FILE freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout)
#define SZ(x) ((int)(x).size())
typedef long double ld;
typedef long long ll;
int gcd(int x,int y){ return (!y ? x : gcd(y, x%y)); }
int to_int(string sconvert){stringstream geek(sconvert);int xconvert = 0; geek >> xconvert; return xconvert;}
const int MAXN=1e6+30,MAX_LOG=20,MOD=1e9+7,INF=1e9;
const double PI = acos(-1);
int mod(int x) { return (x % MOD + MOD) % MOD; }
int power(int x, int y) {
    if(y==0)return 1;
    int prs=(power(x,y/2)%MOD);
    if(y%2==0)return (prs*prs)%MOD;
    else return (prs*prs*x)%MOD;
}
int n,k,a,b;
string s;
int MAIN(){
    cin>>k>>a>>b>>s;
    if(k*a>s.size())die("No solution");
    while((s.size()-((k-1)*a))>b && a<=b)a++;
    if(a>b)die("No solution");
    string s2="";
    int cnt=0;
    for(int i=0;i<s.size();i++){
        if(i%a==0 && i!=0){
            cnt++;
            if(cnt<k){
                cout<<s2<<endl;s2="";
            }
            else if(cnt==k){
                cout<<s2;s2="";
            }

        }
        s2+=s[i];
    }
    cout<<s2<<endl;

    return 0;
}
int32_t main(){
    IOS;
    int t=1;
    //cin>>t;
    while(t--)MAIN();
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define int long long
#define die(x) return cout << x << endl, 0
#define all(o) o.begin(), o.end()
#define endl '\n'
#define IOS ios::sync_with_stdio(0), cin.tie(0)
#define FILE freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout)
#define SZ(x) ((int)(x).size())
typedef long double ld;
typedef long long ll;
int gcd(int x,int y){ return (!y ? x : gcd(y, x%y)); }
int to_int(string sconvert){stringstream geek(sconvert);int xconvert = 0; geek >> xconvert; return xconvert;}
const int MAXN=1e6+30,MAX_LOG=20,MOD=1e9+7,INF=1e9;
const double PI = acos(-1);
int mod(int x) { return (x % MOD + MOD) % MOD; }
int power(int x, int y) {
    if(y==0)return 1;
    int prs=(power(x,y/2)%MOD);
    if(y%2==0)return (prs*prs)%MOD;
    else return (prs*prs*x)%MOD;
}
int n,k,a,b;
string s;
int MAIN(){
    cin>>k>>a>>b>>s;
    while((s.size()-((k-1)*a))>b && a<b)a++;
    if(a==b)die("No solution");
    string s2="";
    for(int i=0;i<s.size();i++){
        if(i%a==0 && i!=0){
            if(i+a<=s.size())cout<<s2<<endl;
            else cout<<s2;
            s2="";
        }
        s2+=s[i];
    }
    cout<<s2<<endl;

    return 0;
}
int32_t main(){
    IOS;
    int t=1;
    //cin>>t;
    while(t--)MAIN();
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define int long long
#define die(x) return cout << x << endl, 0
#define all(o) o.begin(), o.end()
#define endl '\n'
#define IOS ios::sync_with_stdio(0), cin.tie(0)
#define FILE freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout)
#define SZ(x) ((int)(x).size())
typedef long double ld;
typedef long long ll;
int gcd(int x,int y){ return (!y ? x : gcd(y, x%y)); }
int to_int(string sconvert){stringstream geek(sconvert);int xconvert = 0; geek >> xconvert; return xconvert;}
const int MAXN=1e6+30,MAX_LOG=20,MOD=1e9+7,INF=1e9;
const double PI = acos(-1);
int mod(int x) { return (x % MOD + MOD) % MOD; }
int power(int x, int y) {
    if(y==0)return 1;
    int prs=(power(x,y/2)%MOD);
    if(y%2==0)return (prs*prs)%MOD;
    else return (prs*prs*x)%MOD;
}
int n,k,a,b;
string s;
int MAIN(){
    cin>>k>>a>>b>>s;
    while((s.size()-((k-1)*a))>b && a<b)a++;
    if(a==b)die("No solution");
    string s2="";
    for(int i=0;i<s.size();i++){
        if(i%a==0){
            if(i+a<=s.size())cout<<s2<<endl;
            else cout<<s2;
            s2="";
        }
        s2+=s[i];
    }
    cout<<s2<<endl;

    return 0;
}
int32_t main(){
    IOS;
    int t=1;
    //cin>>t;
    while(t--)MAIN();
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define int long long
#define die(x) return cout << x << endl, 0
#define all(o) o.begin(), o.end()
#define endl '\n'
#define IOS ios::sync_with_stdio(0), cin.tie(0)
#define FILE freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout)
#define SZ(x) ((int)(x).size())
typedef long double ld;
typedef long long ll;
int gcd(int x,int y){ return (!y ? x : gcd(y, x%y)); }
int to_int(string sconvert){stringstream geek(sconvert);int xconvert = 0; geek >> xconvert; return xconvert;}
const int MAXN=1e6+30,MAX_LOG=20,MOD=1e9+7,INF=1e9;
const double PI = acos(-1);
int mod(int x) { return (x % MOD + MOD) % MOD; }
int power(int x, int y) {
    if(y==0)return 1;
    int prs=(power(x,y/2)%MOD);
    if(y%2==0)return (prs*prs)%MOD;
    else return (prs*prs*x)%MOD;
}
int n,k,a,b;
string s;
int MAIN(){
    cin>>k>>a>>b>>s;
    while((s.size()-((k-1)*a))>b && a<=b)a++;
    if(a>b)die("No solution");
    string s2="";
    for(int i=0;i<s.size();i++){
        if(i%a==0 && i!=0){
            if(i+a<=s.size())cout<<s2<<endl;
            else cout<<s2;
            s2="";
        }
        s2+=s[i];
    }
    cout<<s2<<endl;

    return 0;
}
int32_t main(){
    IOS;
    int t=1;
    //cin>>t;
    while(t--)MAIN();
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define int long long
#define die(x) return cout << x << endl, 0
#define all(o) o.begin(), o.end()
#define endl '\n'
#define IOS ios::sync_with_stdio(0), cin.tie(0)
#define FILE freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout)
#define SZ(x) ((int)(x).size())
typedef long double ld;
typedef long long ll;
int gcd(int x,int y){ return (!y ? x : gcd(y, x%y)); }
int to_int(string sconvert){stringstream geek(sconvert);int xconvert = 0; geek >> xconvert; return xconvert;}
const int MAXN=1e6+30,MAX_LOG=20,MOD=1e9+7,INF=1e9;
const double PI = acos(-1);
int mod(int x) { return (x % MOD + MOD) % MOD; }
int power(int x, int y) {
    if(y==0)return 1;
    int prs=(power(x,y/2)%MOD);
    if(y%2==0)return (prs*prs)%MOD;
    else return (prs*prs*x)%MOD;
}
int n,k,a,b;
string s;
int MAIN(){
    cin>>k>>a>>b>>s;
    while((s.size()-((k-1)*a))>b && a<=b)a++;
    if(a>b)die("No solution");
    string s2="";
    int cnt=0;
    for(int i=0;i<s.size();i++){
        if(i%a==0 && i!=0){
            cnt++;
            if(cnt<k){
                cout<<s2<<endl;s2="";
            }
            else if(cnt==k){
                cout<<s2;s2="";
            }

        }
        s2+=s[i];
    }
    cout<<s2<<endl;

    return 0;
}
int32_t main(){
    IOS;
    int t=1;
    //cin>>t;
    while(t--)MAIN();
    return 0;
}


// Author := Abhishek Giri

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define V(type) vector<(type)>
#define all(c) ((c).begin(),(c).end())
#define in(var) cin>>(var)
#define out(var) cout<<(var)
#define on(var) cout<<var<<"\n"
#define f(i,n) for(ll i = 0 ; i < n ;i++)
#define mfor(i,init,n,b) for(ll i = (init) ; i < (n) ; i+= (b))
#define cfor(i,c) for(auto i = (c).begin() ; i!= (c).end(); i++)
#define el "\n"
#define ret return

/*##################################################################################*/

int prime[100000] ;
vector < int > pr;
void calculateprime()
{
    prime[0] = prime[1] = 1 ;
    for(int i = 2 ; i <= 100000 ; i++)
    {
        if(prime[i] == 0)
        {
            pr.pb(i);
            for(ll j = i*2 ; j <= 100000 ; j += i )
            {
                prime[j] = 1 ;
            }
        }
    }
}

void customrun(){
    #ifndef ONLINE_JUDGE
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
}

void fast(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
}

bool isprime(ll n)
{
    for(ll i = 2 ; (ll) i*i <= n ; i++)
    {
        if(n % i == 0){
            return false;
        }
    }
    return true;
}

ll fib(int n)
{
    ll a = 0, b = 1, c, i;
    if( n == 0)
        return a;
    for (i = 2; i <= n; i++)
    {
        c = (a + b);
        a = b;
        b = c;
    }
    return b;
}

ll gcd(ll a, ll b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

ll extendedgcd(ll a, ll b, ll& x, ll& y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    ll x1, y1;
    ll d = extendedgcd(b, a % b, x1, y1);
    x = y1;
    y = x1 - y1 * (a / b);
    return d;
}

ll findgrouplcm(vector<int> &arr, int n)
{
    ll ans = arr[0];

    for (ll i = 1; i < n; i++)
        ans = (arr[i] * (ans/(gcd(arr[i], ans))));

    return ans;
}

ll powerwithmod(ll x, unsigned ll y, ll p)
{
    ll res = 1;

    x = x % p;

    if (x == 0) return 0;

    while (y > 0)
    {
        if (y & 1)
            res = (res*x) % p;

        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

bool comp(const pair < long,long > &a, const pair < long ,long > &b){
    if(a.first == b.first) return a.second < b.second;
    return a.first < b.first;
}

void solve();

int main() {
    clock_t begin = clock();

    fast();
    customrun();
    ll t = 1;
    //cin>>t;
    //calculateprime();
    mfor(i,1,t+1,1)
    {
        //cout<<"Case #"<<i<<": \n";
        solve();
    }

    clock_t end = clock();
    double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
    //cout<<"\ntime spent is "<<time_spent;
    return 0;
}

int res( vector < int > &v , map < int,int > &m , int l ,int r ){
    if(r <= l){
        //cout<<"l and r is "<<l<<" "<<r<<" base case encountered "<<el;
        return 0 ;
    }

    bool ok = (*upper_bound(v.begin()+l,v.begin()+r,2*v[l]) - 2*v[l] <= 0) ;
    //cout<<"l and r is "<<l<<" "<<r<<el;
    if(ok == true) return 0 ;

    int first = m[v[l]] + res(v,m,l+1,r);
    int second = m[v[r]] + res(v,m,l,r-1);
    //cout<<"first val is "<<first<<" second is "<<second<<el;

    return min(first,second);
}

void solve(){
    int k,a,b;
    in(k)>>a>>b;
    string str;
    in(str);
    int n = str.length();

    if(b*k < n ){
        out("No solution");
        ret;
    }

    int l , p;
    for(l = a ; l <= b ; l++){
        if(n%l == 0) p = n/l;
        else p = (n/l)+1;
        if(p == k and l*k >= n) break;
    }

    //cout<<"l is "<<l<<el;
    int i = 0;
    while(p--){
        mfor(j,i,min(n,i+l),1) cout<<str[j];cout<<el;
        i += l;
    }
}


// Author := Abhishek Giri

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define V(type) vector<(type)>
#define all(c) ((c).begin(),(c).end())
#define in(var) cin>>(var)
#define out(var) cout<<(var)
#define on(var) cout<<var<<"\n"
#define f(i,n) for(ll i = 0 ; i < n ;i++)
#define mfor(i,init,n,b) for(ll i = (init) ; i < (n) ; i+= (b))
#define cfor(i,c) for(auto i = (c).begin() ; i!= (c).end(); i++)
#define el "\n"
#define ret return

/*##################################################################################*/

int prime[100000] ;
vector < int > pr;
void calculateprime()
{
    prime[0] = prime[1] = 1 ;
    for(int i = 2 ; i <= 100000 ; i++)
    {
        if(prime[i] == 0)
        {
            pr.pb(i);
            for(ll j = i*2 ; j <= 100000 ; j += i )
            {
                prime[j] = 1 ;
            }
        }
    }
}

void customrun(){
    #ifndef ONLINE_JUDGE
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
}

void fast(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
}

bool isprime(ll n)
{
    for(ll i = 2 ; (ll) i*i <= n ; i++)
    {
        if(n % i == 0){
            return false;
        }
    }
    return true;
}

ll fib(int n)
{
    ll a = 0, b = 1, c, i;
    if( n == 0)
        return a;
    for (i = 2; i <= n; i++)
    {
        c = (a + b);
        a = b;
        b = c;
    }
    return b;
}

ll gcd(ll a, ll b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

ll extendedgcd(ll a, ll b, ll& x, ll& y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    ll x1, y1;
    ll d = extendedgcd(b, a % b, x1, y1);
    x = y1;
    y = x1 - y1 * (a / b);
    return d;
}

ll findgrouplcm(vector<int> &arr, int n)
{
    ll ans = arr[0];

    for (ll i = 1; i < n; i++)
        ans = (arr[i] * (ans/(gcd(arr[i], ans))));

    return ans;
}

ll powerwithmod(ll x, unsigned ll y, ll p)
{
    ll res = 1;

    x = x % p;

    if (x == 0) return 0;

    while (y > 0)
    {
        if (y & 1)
            res = (res*x) % p;

        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

bool comp(const pair < long,long > &a, const pair < long ,long > &b){
    if(a.first == b.first) return a.second < b.second;
    return a.first < b.first;
}

void solve();

int main() {
    clock_t begin = clock();

    fast();
    customrun();
    ll t = 1;
    //cin>>t;
    //calculateprime();
    mfor(i,1,t+1,1)
    {
        //cout<<"Case #"<<i<<": \n";
        solve();
    }

    clock_t end = clock();
    double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
    //cout<<"\ntime spent is "<<time_spent;
    return 0;
}

int res( vector < int > &v , map < int,int > &m , int l ,int r ){
    if(r <= l){
        //cout<<"l and r is "<<l<<" "<<r<<" base case encountered "<<el;
        return 0 ;
    }

    bool ok = (*upper_bound(v.begin()+l,v.begin()+r,2*v[l]) - 2*v[l] <= 0) ;
    //cout<<"l and r is "<<l<<" "<<r<<el;
    if(ok == true) return 0 ;

    int first = m[v[l]] + res(v,m,l+1,r);
    int second = m[v[r]] + res(v,m,l,r-1);
    //cout<<"first val is "<<first<<" second is "<<second<<el;

    return min(first,second);
}

void solve(){
    int k,a,b;
    in(k)>>a>>b;
    string str;
    in(str);
    int n = str.length();

    if(b*k < n or a*k > n){
        out("No solution");
        ret;
    }
    int i = 0 , len = n;
    while(k){
        int l = n/k;
        //cout<<"l is "<<l<<el;

        if(l > b or l < a){
            out("No solution");
            ret;
        }

        n -= l;
        for(int j = i ; j < min(len,i + l) ; j++){
            cout<<str[j];
        }
        cout<<el;
        i = i + l ;
        --k;
    }
}


// Author := Abhishek Giri

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define V(type) vector<(type)>
#define all(c) ((c).begin(),(c).end())
#define in(var) cin>>(var)
#define out(var) cout<<(var)
#define on(var) cout<<var<<"\n"
#define f(i,n) for(ll i = 0 ; i < n ;i++)
#define mfor(i,init,n,b) for(ll i = (init) ; i < (n) ; i+= (b))
#define cfor(i,c) for(auto i = (c).begin() ; i!= (c).end(); i++)
#define el "\n"
#define ret return

/*##################################################################################*/

int prime[100000] ;
vector < int > pr;
void calculateprime()
{
    prime[0] = prime[1] = 1 ;
    for(int i = 2 ; i <= 100000 ; i++)
    {
        if(prime[i] == 0)
        {
            pr.pb(i);
            for(ll j = i*2 ; j <= 100000 ; j += i )
            {
                prime[j] = 1 ;
            }
        }
    }
}

void customrun(){
    #ifndef ONLINE_JUDGE
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    #endif
}

void fast(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
}

bool isprime(ll n)
{
    for(ll i = 2 ; (ll) i*i <= n ; i++)
    {
        if(n % i == 0){
            return false;
        }
    }
    return true;
}

ll fib(int n)
{
    ll a = 0, b = 1, c, i;
    if( n == 0)
        return a;
    for (i = 2; i <= n; i++)
    {
        c = (a + b);
        a = b;
        b = c;
    }
    return b;
}

ll gcd(ll a, ll b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

ll extendedgcd(ll a, ll b, ll& x, ll& y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    ll x1, y1;
    ll d = extendedgcd(b, a % b, x1, y1);
    x = y1;
    y = x1 - y1 * (a / b);
    return d;
}

ll findgrouplcm(vector<int> &arr, int n)
{
    ll ans = arr[0];

    for (ll i = 1; i < n; i++)
        ans = (arr[i] * (ans/(gcd(arr[i], ans))));

    return ans;
}

ll powerwithmod(ll x, unsigned ll y, ll p)
{
    ll res = 1;

    x = x % p;

    if (x == 0) return 0;

    while (y > 0)
    {
        if (y & 1)
            res = (res*x) % p;

        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

bool comp(const pair < long,long > &a, const pair < long ,long > &b){
    if(a.first == b.first) return a.second < b.second;
    return a.first < b.first;
}

void solve();

int main() {
    clock_t begin = clock();

    fast();
    customrun();
    ll t = 1;
    //cin>>t;
    //calculateprime();
    mfor(i,1,t+1,1)
    {
        //cout<<"Case #"<<i<<": \n";
        solve();
    }

    clock_t end = clock();
    double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
    //cout<<"\ntime spent is "<<time_spent;
    return 0;
}

int res( vector < int > &v , map < int,int > &m , int l ,int r ){
    if(r <= l){
        //cout<<"l and r is "<<l<<" "<<r<<" base case encountered "<<el;
        return 0 ;
    }

    bool ok = (*upper_bound(v.begin()+l,v.begin()+r,2*v[l]) - 2*v[l] <= 0) ;
    //cout<<"l and r is "<<l<<" "<<r<<el;
    if(ok == true) return 0 ;

    int first = m[v[l]] + res(v,m,l+1,r);
    int second = m[v[r]] + res(v,m,l,r-1);
    //cout<<"first val is "<<first<<" second is "<<second<<el;

    return min(first,second);
}

void solve(){
    int k,a,b;
    in(k)>>a>>b;
    string str;
    in(str);
    int n = str.length();

    if(b*k < n ){
        out("No solution");
        ret;
    }

    int l , p;
    for(l = a ; l <= b ; l++){
        if(n%l == 0) p = n/l;
        p = (n/l)+1;
        if(p == k and l*k >= n) break;
    }

    //cout<<"l is "<<l<<el;
    int i = 0;
    while(p--){
        mfor(j,i,min(n,i+l),1) cout<<str[j];cout<<el;
        i += l;
    }
}


// Author := Abhishek Giri

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define V(type) vector<(type)>
#define all(c) ((c).begin(),(c).end())
#define in(var) cin>>(var)
#define out(var) cout<<(var)
#define on(var) cout<<var<<"\n"
#define f(i,n) for(ll i = 0 ; i < n ;i++)
#define mfor(i,init,n,b) for(ll i = (init) ; i < (n) ; i+= (b))
#define cfor(i,c) for(auto i = (c).begin() ; i!= (c).end(); i++)
#define el "\n"
#define ret return

/*##################################################################################*/

int prime[100000] ;
vector < int > pr;
void calculateprime()
{
    prime[0] = prime[1] = 1 ;
    for(int i = 2 ; i <= 100000 ; i++)
    {
        if(prime[i] == 0)
        {
            pr.pb(i);
            for(ll j = i*2 ; j <= 100000 ; j += i )
            {
                prime[j] = 1 ;
            }
        }
    }
}

void customrun(){
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
}

void fast(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
}

bool isprime(ll n)
{
    for(ll i = 2 ; (ll) i*i <= n ; i++)
    {
        if(n % i == 0){
            return false;
        }
    }
    return true;
}

ll fib(int n)
{
    ll a = 0, b = 1, c, i;
    if( n == 0)
        return a;
    for (i = 2; i <= n; i++)
    {
        c = (a + b);
        a = b;
        b = c;
    }
    return b;
}

ll gcd(ll a, ll b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

ll extendedgcd(ll a, ll b, ll& x, ll& y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    ll x1, y1;
    ll d = extendedgcd(b, a % b, x1, y1);
    x = y1;
    y = x1 - y1 * (a / b);
    return d;
}

ll findgrouplcm(vector<int> &arr, int n)
{
    ll ans = arr[0];

    for (ll i = 1; i < n; i++)
        ans = (arr[i] * (ans/(gcd(arr[i], ans))));

    return ans;
}

ll powerwithmod(ll x, unsigned ll y, ll p)
{
    ll res = 1;

    x = x % p;

    if (x == 0) return 0;

    while (y > 0)
    {
        if (y & 1)
            res = (res*x) % p;

        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res;
}

bool comp(const pair < long,long > &a, const pair < long ,long > &b){
    if(a.first == b.first) return a.second < b.second;
    return a.first < b.first;
}

void solve();

int main() {
    clock_t begin = clock();

    fast();
    customrun();
    ll t = 1;
    //cin>>t;
    //calculateprime();
    mfor(i,1,t+1,1)
    {
        //cout<<"Case #"<<i<<": \n";
        solve();
    }

    clock_t end = clock();
    double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
    //cout<<"\ntime spent is "<<time_spent;
    return 0;
}

int res( vector < int > &v , map < int,int > &m , int l ,int r ){
    if(r <= l){
        //cout<<"l and r is "<<l<<" "<<r<<" base case encountered "<<el;
        return 0 ;
    }

    bool ok = (*upper_bound(v.begin()+l,v.begin()+r,2*v[l]) - 2*v[l] <= 0) ;
    //cout<<"l and r is "<<l<<" "<<r<<el;
    if(ok == true) return 0 ;

    int first = m[v[l]] + res(v,m,l+1,r);
    int second = m[v[r]] + res(v,m,l,r-1);
    //cout<<"first val is "<<first<<" second is "<<second<<el;

    return min(first,second);
}

void solve(){
    int k,a,b;
    in(k)>>a>>b;
    string str;
    in(str);
    int n = str.length();

    if(b*k < n ){
        out("No solution");
        ret;
    }

    int l , p;
    for(l = a ; l <= b ; l++){
        if(n%l == 0) p = n/l;
        p = (n/l)+1;
        if(p == k and l*k >= n) break;
    }

    //cout<<"l is "<<l<<el;
    int i = 0;
    while(p--){
        mfor(j,i,min(n,i+l),1) cout<<str[j];cout<<el;
        i += l;
    }
}


/***
	chauhan176's code
***/
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define ll long long int
#define fi first
#define se second
#define maxn 4000
#define stringio cin.ignore(256, '\n')  //to take string input after taking integer inputs
#define go_t int t;cin>>t;while(t--)
#define go_pt int t;cin>>t;for(int tt=1;tt<=t;tt++)
#define set_ar(arr,v) memset(arr,v,sizeof(arr))

typedef pair<int,int>pii[maxn];
int setBitNumber(int n)
{
    if (n == 0)
        return 0;

    int msb = 0;
    while (n != 0) {
        n = n / 2;
        msb++;
    }

    return msb-1;
}
int main()
{
    #ifndef ONLINE_JUDGE
    // for getting input from input.txt
    //freopen("input.txt", "r", stdin);
    // for writing output to output.txt
    //freopen("output1.txt", "w", stdout);
    #endif

    ios_base::sync_with_stdio(false);

    int n,l,r;
    cin>>n>>l>>r;
    stringio;
    string s;
    getline(cin,s);

    int len = s.size();
    int length = len;
    //cout<<length<<endl;
    int arr[maxn];
    set_ar(arr,0);
    for(int i=1;i<=n;i++)
    {
        arr[i]=l;
        len-=l;
    }
    r=r-l;
    if(len<0)
    {
        cout<<"No solution";
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        if(len>0){
            arr[i]+=min(r,len);
            len-=min(r,len);
        }
    }
    if(len>0)
    {
        cout<<"No solution";
        return 0;
    }
    int breakk[maxn];
    set_ar(breakk,0);
    for(int i=1;i<=n;i++)
    {
        arr[i]=arr[i] + arr[i-1];
        breakk[arr[i]]=1;
    }

    for(int i=1;i<=length;i++)
    {
        cout<<s[i-1];

        if(breakk[i]==1)
            cout<<endl;
    }
    return 0;
}


/***
	chauhan176's code
***/
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define ll long long int
#define fi first
#define se second
#define maxn 4000
#define stringio cin.ignore(256, '\n')  //to take string input after taking integer inputs
#define go_t int t;cin>>t;while(t--)
#define go_pt int t;cin>>t;for(int tt=1;tt<=t;tt++)
#define set_ar(arr,v) memset(arr,v,sizeof(arr))

typedef pair<int,int>pii[maxn];
int setBitNumber(int n)
{
    if (n == 0)
        return 0;

    int msb = 0;
    while (n != 0) {
        n = n / 2;
        msb++;
    }

    return msb-1;
}
int main()
{
    #ifndef ONLINE_JUDGE
    // for getting input from input.txt
    //freopen("input.txt", "r", stdin);
    // for writing output to output.txt
    //freopen("output1.txt", "w", stdout);
    #endif

    ios_base::sync_with_stdio(false);

    int n,l,r;
    cin>>n>>l>>r;
    stringio;
    string s;
    getline(cin,s);

    int len = s.size();
    int length = len;
    cout<<length<<endl;
    int arr[maxn];
    set_ar(arr,0);
    for(int i=1;i<=n;i++)
    {
        arr[i]=l;
        len-=l;
    }
    r=r-l;
    if(len<0)
    {
        cout<<"No solution";
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        if(len>0){
            arr[i]+=min(r,len);
            len-=min(r,len);
        }
    }
    if(len>0)
    {
        cout<<"No solution";
        return 0;
    }
    int breakk[maxn];
    set_ar(breakk,0);
    for(int i=1;i<=n;i++)
    {
        arr[i]=arr[i] + arr[i-1];
        breakk[arr[i]]=1;
    }

    for(int i=1;i<=length;i++)
    {
        cout<<s[i-1];

        if(breakk[i]==1)
            cout<<endl;
    }
    return 0;
}


/***
	chauhan176's code
***/
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define ll long long int
#define fi first
#define se second
#define maxn 400005
#define stringio cin.ignore(256, '\n')  //to take string input after taking integer inputs
#define go_t int t;cin>>t;while(t--)
#define go_pt int t;cin>>t;for(int tt=1;tt<=t;tt++)
#define set_ar(arr,v) memset(arr,v,sizeof(arr))

typedef pair<int,int>pii[maxn];
int setBitNumber(int n)
{
    if (n == 0)
        return 0;

    int msb = 0;
    while (n != 0) {
        n = n / 2;
        msb++;
    }

    return msb-1;
}
int main()
{
    #ifndef ONLINE_JUDGE
    // for getting input from input.txt
    //freopen("input.txt", "r", stdin);
    // for writing output to output.txt
    //freopen("output1.txt", "w", stdout);
    #endif

    ios_base::sync_with_stdio(false);

    int n,l,r;
    cin>>n>>l>>r;
    stringio;
    string s;
    cin>>s;

    int len = s.size();
    int length = len;
    int arr[n+2];
    set_ar(arr,0);
    for(int i=1;i<=n;i++)
    {
        arr[i]=l;
        len-=l;
    }
    r=r-l;
    if(len<0)
    {
        cout<<"No solution";
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        if(len>0){
            arr[i]+=min(r,len);
            len-=min(r,len);
        }
    }
    if(len>0)
    {
        cout<<"No solution";
        return 0;
    }
    int breakk[n+2];
    set_ar(breakk,0);
    for(int i=1;i<=n;i++)
    {
        arr[i]+=arr[i-1];
        breakk[arr[i]]=1;
    }

    for(int i=1;i<=length;i++)
    {
        cout<<s[i-1];

        if(breakk[i]==1)
            cout<<endl;
    }
    return 0;
}


/***
	chauhan176's code
***/
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define ll long long int
#define fi first
#define se second
#define maxn 400005
#define stringio cin.ignore(256, '\n')  //to take string input after taking integer inputs
#define go_t int t;cin>>t;while(t--)
#define go_pt int t;cin>>t;for(int tt=1;tt<=t;tt++)
#define set_ar(arr,v) memset(arr,v,sizeof(arr))

typedef pair<int,int>pii[maxn];
int setBitNumber(int n)
{
    if (n == 0)
        return 0;

    int msb = 0;
    while (n != 0) {
        n = n / 2;
        msb++;
    }

    return msb-1;
}
int main()
{
    #ifndef ONLINE_JUDGE
    // for getting input from input.txt
    //freopen("input.txt", "r", stdin);
    // for writing output to output.txt
    //freopen("output1.txt", "w", stdout);
    #endif

    ios_base::sync_with_stdio(false);

    int n,l,r;
    cin>>n>>l>>r;
    stringio;
    string s;
    cin>>s;

    int len = s.size();
    int length = len;
    int arr[length+2];
    set_ar(arr,0);
    for(int i=1;i<=n;i++)
    {
        arr[i]=l;
        len-=l;
    }
    r=r-l;
    if(len<0)
    {
        cout<<"No solution";
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        if(len>0){
            arr[i]+=min(r,len);
            len-=min(r,len);
        }
    }
    if(len>0)
    {
        cout<<"No solution";
        return 0;
    }
    int breakk[length+2];
    set_ar(breakk,0);
    for(int i=1;i<=n;i++)
    {
        arr[i]=arr[i] + arr[i-1];
        breakk[arr[i]]=1;
    }

    for(int i=1;i<=length;i++)
    {
        cout<<s[i-1];

        if(breakk[i]==1)
            cout<<endl;
    }
    return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
//#include <boost/multiprecision/cpp_int.hpp>
//
//using namespace boost::multiprecision;
using namespace __gnu_pbds;
using namespace std;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;

/*** Typedef ***/
typedef   long long ll;
typedef long long int lli;
typedef unsigned long long ull;
typedef   long double   ld;

//typedef    unordered_set<ll>   usll;
//typedef    unordered_multiset<ll>   umsll;

/*** Loops ***/
#define ffit(i, dat)    for (__typeof(dat.begin()) i = dat.begin(); i != dat.end(); ++i)
#define yo(a,b) for(int i = a; i < b; i++)
#define ff1(i,a,b) for(ll i = a; i < b; i++)
#define ff2(i,a,b) for(ll i = b-1; i >= a; i--)
#define ff3(i,a,b,m) for(ll i = a; i <b; i+=m)
#define ipar(ar,n) ll ar[n]; ff1(i,0,n) cin>>ar[i];
#define opar(ar,n) ff1(i,0,n) cout<<ar[i]<<" ";
#define foRev(num) for(ll i = num - 1; i >= 0; i--)
#define forIn(arr, num) for(ll i = 0; i < num; i++) sc1(arr[i]);
#define forIn1(arr, num) for(ll i = 1; i <= num; i++) sc1(arr[i]);
#define vpnt(ans) for(ll i = 0; i < ans.size(); i++) cout << ans[i] << (i + 1 < ans.size() ? ' ' : '\n');
#define apnt(arr, num) for(ll i = 0; i < num; i++) cout << arr[i] << (i + 1 < num ? ' ' : '\n');

/*** Define Values ***/

#define PI acos(-1.0)
#define eps 1e-7
#define size1 15
const ll mdd = (ll)1e9 + 7;
/*** STLs ***/
#define sf(a)            scanf("%lld",&a)
#define sff(a,b)         scanf("%lld %lld",&a,&b)
#define sfff(a,b,c)      scanf("%lld %lld %lld",&a,&b,&c)
#define cu continue
#define br break
#define rsz resize
#define ins insert
#define ft front
#define bk back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define ff first
#define ss second
#define mp make_pair
#define rr return
#define nxt   next_permutation
#define mem(name, value) memset(name, value, sizeof(name))
#define MN3(n1,n2,n3) min(n1,min(n2,n3))
#define MN4(n1,n2,n3,n4) min(n1,min(n2,min(n3,n4)))
#define MX3(n1,n2,n3) max(n1,max(n2,n3))
#define MX4(n1,n2,n3,n4) max(n1,max(n2,max(n3,n4)))
#define mxar(a,n) *max_element(a,a+n)
#define mnar(a,n) *min_element(a,a+n)
#define arr_sm(a,n) accumulate(a,a+n,0)
#define vc_sm(ve) accumulate(ve.begin(),ve.end(),0)
#define mx_vc(ve) *max_element(ve.begin(),ve.end())
#define mn_vc(ve) *min_element(ve.begin(),ve.end())
//#define endl " \n"

/*** STLs ***/
typedef vector <ll> vll;
#define vvll vector<vll>
typedef set <ll> sll;
typedef multiset <ll> msll;
typedef multimap <ll,ll> mpll;
typedef queue <ll> qll;
typedef map <ll, ll> mll;
typedef pair <ll, ll> pll;
typedef vector <pair <ll, ll> > vpll;
typedef priority_queue <pair <ll, ll> > pqpll;
#define uniq(v)           (v).erase(unique(all(v)),(v).end())
#define maxpq priority_queue<ll>
#define minpq priority_queue<ll, vector<ll>, greater<ll> >
#define ml unordered_map<ll,ll>
///typedef    unordered_multiset<int>   umsi;
typedef    unordered_set<ll>   us;

///vector<vector<int>> v(10, vector<int>(20,500)); 2d vector initialization. of 10 rows and 20 columns, with value 500.

/*** Sorts ***/
#define czero(n)                    __builtin_popcountll(n) // count the number of 1's in the bit representation of a number
#define cenzero(n)                  __builtin_ctzll(n) // count the number of zereos from the end of the bit representation of a number until a 1
#define countbegzero(n)             __builtin_clzxll(n)
#define checkparity(n)              __builtin_parityll(n)// checks whether the number of bits are even or odd
#define all(v) (v).begin(), (v).end()
#define rev(v) reverse(all(v))
#define srt(v) sort(all(v))
#define srtgrt(v) sort(all(v), greater<ll>())
#define prsrt greater<pair<int,int>>()
/*** Some Prints ***/
#define ip(n) ll n; cin>>n;
#define is(s) string s; cin>>s;
#define ipp(n,k) ll n; cin>>n; ll k; cin>>k;
#define ip3(n,m,k) ll n; cin>>n;ll m;cin>>m; ll k; cin>>k;
#define kl    '\n'
#define case cout << "Case " << t++ << ": ";
#define ps(x,y)         fixed<<setprecision(y)<<x
#define inf             1e18
#define w(x)             ll x; cin>>x; while(x--)
#define go(i, a) for (auto &i : a)
#define go1(it, v) for(auto it = v.rbegin(); it != v.rend(); ++it)
//#define mk(arr,n,type) type *arr=new type[n];
#define sz(obj) (int(obj.size()))
#define ipve(vc,n) vll vc(n); ff1(i,0,n){cin>>vc[i];}
#define ipvc(vc,n) vll vc; ff1(i,0,n){ip(x);vc.pb(x);}
#define cer cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
#define depressed()                    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
//bool ans = all_of(arr, arr + 6, [](int x) {return x & 1; } );
const double pi = 3.141592653589793238460;
#define TRC
#ifdef TRC
#define trc(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cout << name << " : " << arg1 << endl;
        //use cerr if u want to display at the bottom
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ','); cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
    }
#else
#define trc(...)
#endif
#define no cout << "NO" << '\n'
#define yes cout << "YES" << '\n'
ll dx[8]={+1, +1, +1, 0, 0, -1, -1, -1};
ll dy[8] = {-1, 0, +1, -1, +1, -1, 0, +1};

void fun()
{
   ip3(k,a,b);
   is(s);
   ll n = sz(s);
   ff2(i,a,b+1)
   {
    if(n%i == 0)
    {
      ll p =  n/i;
      for(ll j = 0;j+i<n;j+=i)
      {
         string ss = s.substr(j,i);
         cout<<ss<<kl;
      }
      rr;
    }
    ll p = n/i;
    ll rm = n%i;
    if(p<k && rm >= a)
    {
      ll j = 0;
      for(j = 0;j+i<n;j+=i)
      {
         string ss = s.substr(j,i);
         cout<<ss<<kl;
      }
      ll q = n%i;
      string ss = s.substr(j,q);
      cout<<ss;rr;
    }
   }
   cout<<"No solution";
}

int main()
{
// tasklist
// taskkill /f /im mo.exe

    depressed();
  ll tc = 1;
  // seive(1e6);
 //cin>>tc;
  while(tc--)
  {
     fun();
  }
  //cer;
  return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
//#include <boost/multiprecision/cpp_int.hpp>
//
//using namespace boost::multiprecision;
using namespace __gnu_pbds;
using namespace std;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;

/*** Typedef ***/
typedef   long long ll;
typedef long long int lli;
typedef unsigned long long ull;
typedef   long double   ld;

//typedef    unordered_set<ll>   usll;
//typedef    unordered_multiset<ll>   umsll;

/*** Loops ***/
#define ffit(i, dat)    for (__typeof(dat.begin()) i = dat.begin(); i != dat.end(); ++i)
#define yo(a,b) for(int i = a; i < b; i++)
#define ff1(i,a,b) for(ll i = a; i < b; i++)
#define ff2(i,a,b) for(ll i = b-1; i >= a; i--)
#define ff3(i,a,b,m) for(ll i = a; i <b; i+=m)
#define ipar(ar,n) ll ar[n]; ff1(i,0,n) cin>>ar[i];
#define opar(ar,n) ff1(i,0,n) cout<<ar[i]<<" ";
#define foRev(num) for(ll i = num - 1; i >= 0; i--)
#define forIn(arr, num) for(ll i = 0; i < num; i++) sc1(arr[i]);
#define forIn1(arr, num) for(ll i = 1; i <= num; i++) sc1(arr[i]);
#define vpnt(ans) for(ll i = 0; i < ans.size(); i++) cout << ans[i] << (i + 1 < ans.size() ? ' ' : '\n');
#define apnt(arr, num) for(ll i = 0; i < num; i++) cout << arr[i] << (i + 1 < num ? ' ' : '\n');

/*** Define Values ***/

#define PI acos(-1.0)
#define eps 1e-7
#define size1 15
const ll mdd = (ll)1e9 + 7;
/*** STLs ***/
#define sf(a)            scanf("%lld",&a)
#define sff(a,b)         scanf("%lld %lld",&a,&b)
#define sfff(a,b,c)      scanf("%lld %lld %lld",&a,&b,&c)
#define cu continue
#define br break
#define rsz resize
#define ins insert
#define ft front
#define bk back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define ff first
#define ss second
#define mp make_pair
#define rr return
#define nxt   next_permutation
#define mem(name, value) memset(name, value, sizeof(name))
#define MN3(n1,n2,n3) min(n1,min(n2,n3))
#define MN4(n1,n2,n3,n4) min(n1,min(n2,min(n3,n4)))
#define MX3(n1,n2,n3) max(n1,max(n2,n3))
#define MX4(n1,n2,n3,n4) max(n1,max(n2,max(n3,n4)))
#define mxar(a,n) *max_element(a,a+n)
#define mnar(a,n) *min_element(a,a+n)
#define arr_sm(a,n) accumulate(a,a+n,0)
#define vc_sm(ve) accumulate(ve.begin(),ve.end(),0)
#define mx_vc(ve) *max_element(ve.begin(),ve.end())
#define mn_vc(ve) *min_element(ve.begin(),ve.end())
//#define endl " \n"

/*** STLs ***/
typedef vector <ll> vll;
#define vvll vector<vll>
typedef set <ll> sll;
typedef multiset <ll> msll;
typedef multimap <ll,ll> mpll;
typedef queue <ll> qll;
typedef map <ll, ll> mll;
typedef pair <ll, ll> pll;
typedef vector <pair <ll, ll> > vpll;
typedef priority_queue <pair <ll, ll> > pqpll;
#define uniq(v)           (v).erase(unique(all(v)),(v).end())
#define maxpq priority_queue<ll>
#define minpq priority_queue<ll, vector<ll>, greater<ll> >
#define ml unordered_map<ll,ll>
///typedef    unordered_multiset<int>   umsi;
typedef    unordered_set<ll>   us;

///vector<vector<int>> v(10, vector<int>(20,500)); 2d vector initialization. of 10 rows and 20 columns, with value 500.

/*** Sorts ***/
#define czero(n)                    __builtin_popcountll(n) // count the number of 1's in the bit representation of a number
#define cenzero(n)                  __builtin_ctzll(n) // count the number of zereos from the end of the bit representation of a number until a 1
#define countbegzero(n)             __builtin_clzxll(n)
#define checkparity(n)              __builtin_parityll(n)// checks whether the number of bits are even or odd
#define all(v) (v).begin(), (v).end()
#define rev(v) reverse(all(v))
#define srt(v) sort(all(v))
#define srtgrt(v) sort(all(v), greater<ll>())
#define prsrt greater<pair<int,int>>()
/*** Some Prints ***/
#define ip(n) ll n; cin>>n;
#define is(s) string s; cin>>s;
#define ipp(n,k) ll n; cin>>n; ll k; cin>>k;
#define ip3(n,m,k) ll n; cin>>n;ll m;cin>>m; ll k; cin>>k;
#define kl    '\n'
#define case cout << "Case " << t++ << ": ";
#define ps(x,y)         fixed<<setprecision(y)<<x
#define inf             1e18
#define w(x)             ll x; cin>>x; while(x--)
#define go(i, a) for (auto &i : a)
#define go1(it, v) for(auto it = v.rbegin(); it != v.rend(); ++it)
//#define mk(arr,n,type) type *arr=new type[n];
#define sz(obj) (int(obj.size()))
#define ipve(vc,n) vll vc(n); ff1(i,0,n){cin>>vc[i];}
#define ipvc(vc,n) vll vc; ff1(i,0,n){ip(x);vc.pb(x);}
#define cer cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
#define depressed()                    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
//bool ans = all_of(arr, arr + 6, [](int x) {return x & 1; } );
const double pi = 3.141592653589793238460;
#define TRC
#ifdef TRC
#define trc(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cout << name << " : " << arg1 << endl;
        //use cerr if u want to display at the bottom
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ','); cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
    }
#else
#define trc(...)
#endif
#define no cout << "NO" << '\n'
#define yes cout << "YES" << '\n'
ll dx[8]={+1, +1, +1, 0, 0, -1, -1, -1};
ll dy[8] = {-1, 0, +1, -1, +1, -1, 0, +1};

void fun()
{
   ip3(k,a,b);
   is(s);
   ll n = sz(s);
   ff1(i,a,b+1)
   {
    if(n%i == 0 && n/i == k)
    {
      ll p =  n/i;
      for(ll j = 0;j+i<=n;j+=i)
      {
         string ss = s.substr(j,i);
         cout<<ss<<kl;
      }
      rr;
    }
    ll p = n/i;
    ll rm = n%i;
    if(p<k && rm >= a)
    {
      ll j = 0;
      for(j = 0;j+i<=n;j+=i)
      {
         string ss = s.substr(j,i);
         cout<<ss<<kl;
      }
      ll q = n%i;
      string ss = s.substr(j,q);
      cout<<ss;rr;
    }
   }
    ff2(i,a,b+1)
   {
    ll p = n/i;
    ff1(j,1,p+1)
    {
      ll m = n;
      m-=j*i;
      ff1(x,i+1,b+1)
      {
        if(m%x == 0 && m/x == k-j)
        {
          ll q = 0;
          while(j--)
          {
            string ss = s.substr(q,i);
            cout<<ss<<kl;
            q+=i;
          }
           ll y = m/x;
           while(y--)
           {
            string ss = s.substr(q,x);
            cout<<ss<<kl;
            q+=x;
           }rr;
        }

      }
    }
   }
   cout<<"No solution";
}

int main()
{
// tasklist
// taskkill /f /im mo.exe

    depressed();
  ll tc = 1;
  // seive(1e6);
 //cin>>tc;
  while(tc--)
  {
     fun();
  }
  //cer;
  return 0;
}


#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
//#include <boost/multiprecision/cpp_int.hpp>
//
//using namespace boost::multiprecision;
using namespace __gnu_pbds;
using namespace std;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;

/*** Typedef ***/
typedef   long long ll;
typedef long long int lli;
typedef unsigned long long ull;
typedef   long double   ld;

//typedef    unordered_set<ll>   usll;
//typedef    unordered_multiset<ll>   umsll;

/*** Loops ***/
#define ffit(i, dat)    for (__typeof(dat.begin()) i = dat.begin(); i != dat.end(); ++i)
#define yo(a,b) for(int i = a; i < b; i++)
#define ff1(i,a,b) for(ll i = a; i < b; i++)
#define ff2(i,a,b) for(ll i = b-1; i >= a; i--)
#define ff3(i,a,b,m) for(ll i = a; i <b; i+=m)
#define ipar(ar,n) ll ar[n]; ff1(i,0,n) cin>>ar[i];
#define opar(ar,n) ff1(i,0,n) cout<<ar[i]<<" ";
#define foRev(num) for(ll i = num - 1; i >= 0; i--)
#define forIn(arr, num) for(ll i = 0; i < num; i++) sc1(arr[i]);
#define forIn1(arr, num) for(ll i = 1; i <= num; i++) sc1(arr[i]);
#define vpnt(ans) for(ll i = 0; i < ans.size(); i++) cout << ans[i] << (i + 1 < ans.size() ? ' ' : '\n');
#define apnt(arr, num) for(ll i = 0; i < num; i++) cout << arr[i] << (i + 1 < num ? ' ' : '\n');

/*** Define Values ***/

#define PI acos(-1.0)
#define eps 1e-7
#define size1 15
const ll mdd = (ll)1e9 + 7;
/*** STLs ***/
#define sf(a)            scanf("%lld",&a)
#define sff(a,b)         scanf("%lld %lld",&a,&b)
#define sfff(a,b,c)      scanf("%lld %lld %lld",&a,&b,&c)
#define cu continue
#define br break
#define rsz resize
#define ins insert
#define ft front
#define bk back
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define ff first
#define ss second
#define mp make_pair
#define rr return
#define nxt   next_permutation
#define mem(name, value) memset(name, value, sizeof(name))
#define MN3(n1,n2,n3) min(n1,min(n2,n3))
#define MN4(n1,n2,n3,n4) min(n1,min(n2,min(n3,n4)))
#define MX3(n1,n2,n3) max(n1,max(n2,n3))
#define MX4(n1,n2,n3,n4) max(n1,max(n2,max(n3,n4)))
#define mxar(a,n) *max_element(a,a+n)
#define mnar(a,n) *min_element(a,a+n)
#define arr_sm(a,n) accumulate(a,a+n,0)
#define vc_sm(ve) accumulate(ve.begin(),ve.end(),0)
#define mx_vc(ve) *max_element(ve.begin(),ve.end())
#define mn_vc(ve) *min_element(ve.begin(),ve.end())
//#define endl " \n"

/*** STLs ***/
typedef vector <ll> vll;
#define vvll vector<vll>
typedef set <ll> sll;
typedef multiset <ll> msll;
typedef multimap <ll,ll> mpll;
typedef queue <ll> qll;
typedef map <ll, ll> mll;
typedef pair <ll, ll> pll;
typedef vector <pair <ll, ll> > vpll;
typedef priority_queue <pair <ll, ll> > pqpll;
#define uniq(v)           (v).erase(unique(all(v)),(v).end())
#define maxpq priority_queue<ll>
#define minpq priority_queue<ll, vector<ll>, greater<ll> >
#define ml unordered_map<ll,ll>
///typedef    unordered_multiset<int>   umsi;
typedef    unordered_set<ll>   us;

///vector<vector<int>> v(10, vector<int>(20,500)); 2d vector initialization. of 10 rows and 20 columns, with value 500.

/*** Sorts ***/
#define czero(n)                    __builtin_popcountll(n) // count the number of 1's in the bit representation of a number
#define cenzero(n)                  __builtin_ctzll(n) // count the number of zereos from the end of the bit representation of a number until a 1
#define countbegzero(n)             __builtin_clzxll(n)
#define checkparity(n)              __builtin_parityll(n)// checks whether the number of bits are even or odd
#define all(v) (v).begin(), (v).end()
#define rev(v) reverse(all(v))
#define srt(v) sort(all(v))
#define srtgrt(v) sort(all(v), greater<ll>())
#define prsrt greater<pair<int,int>>()
/*** Some Prints ***/
#define ip(n) ll n; cin>>n;
#define is(s) string s; cin>>s;
#define ipp(n,k) ll n; cin>>n; ll k; cin>>k;
#define ip3(n,m,k) ll n; cin>>n;ll m;cin>>m; ll k; cin>>k;
#define kl    '\n'
#define case cout << "Case " << t++ << ": ";
#define ps(x,y)         fixed<<setprecision(y)<<x
#define inf             1e18
#define w(x)             ll x; cin>>x; while(x--)
#define go(i, a) for (auto &i : a)
#define go1(it, v) for(auto it = v.rbegin(); it != v.rend(); ++it)
//#define mk(arr,n,type) type *arr=new type[n];
#define sz(obj) (int(obj.size()))
#define ipve(vc,n) vll vc(n); ff1(i,0,n){cin>>vc[i];}
#define ipvc(vc,n) vll vc; ff1(i,0,n){ip(x);vc.pb(x);}
#define cer cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
#define depressed()                    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
//bool ans = all_of(arr, arr + 6, [](int x) {return x & 1; } );
const double pi = 3.141592653589793238460;
#define TRC
#ifdef TRC
#define trc(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cout << name << " : " << arg1 << endl;
        //use cerr if u want to display at the bottom
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ','); cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
    }
#else
#define trc(...)
#endif
#define no cout << "NO" << '\n'
#define yes cout << "YES" << '\n'
ll dx[8]={+1, +1, +1, 0, 0, -1, -1, -1};
ll dy[8] = {-1, 0, +1, -1, +1, -1, 0, +1};

void fun()
{
   ip3(k,a,b);
   is(s);
   ll n = sz(s);
   ff2(i,a,b+1)
   {
    if(n%i == 0)
    {
      ll p =  n/i;
      for(ll j = 0;j<n;j+=i)
      {
         string ss = s.substr(j,i);
         cout<<ss<<kl;
      }
      rr;
    }
    ll p = n/i;
    if(p<k)
    {
      ll j = 0;
      for(j = 0;j+p<n;j+=i)
      {
         string ss = s.substr(j,i);
         cout<<ss<<kl;
      }
      ll q = n%i;
      string ss = s.substr(j,q);
      cout<<ss;rr;
    }
   }
}

int main()
{
// tasklist
// taskkill /f /im mo.exe

    depressed();
  ll tc = 1;
  // seive(1e6);
 //cin>>tc;
  while(tc--)
  {
     fun();
  }
  //cer;
  return 0;
}