Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You're a hungry rabbit, and you already have eaten a certain number of carrots,
// but now you need to eat more carrots to complete the day's meals.
// you should return a vector of [ total number of eaten carrots after your meals,
// the number of carrots left after your meals ]
// if there are not enough remaining carrots, you will eat all remaining carrots, but will still be hungry.
// Example:
// >>> eat((5), (6), (10))
// (std::vector<long>({(long)11, (long)4}))
// >>> eat((4), (8), (9))
// (std::vector<long>({(long)12, (long)1}))
// >>> eat((1), (10), (10))
// (std::vector<long>({(long)11, (long)0}))
// >>> eat((2), (11), (5))
// (std::vector<long>({(long)7, (long)0}))
// Variables:
// @number : integer
// the number of carrots that you have eaten.
// @need : integer
// the number of carrots that you need to eat.
// @remaining : integer
// the number of remaining carrots thet exist in stock
// Constrain:
// * 0 <= number <= 1000
// * 0 <= need <= 1000
// * 0 <= remaining <= 1000
// Have fun :)
std::vector<long> eat(long number, long need, long remaining) {

}
int main() {
    auto candidate = eat;
    assert(candidate((5), (6), (10)) == (std::vector<long>({(long)11, (long)4})));
    assert(candidate((4), (8), (9)) == (std::vector<long>({(long)12, (long)1})));
    assert(candidate((1), (10), (10)) == (std::vector<long>({(long)11, (long)0})));
    assert(candidate((2), (11), (5)) == (std::vector<long>({(long)7, (long)0})));
    assert(candidate((4), (5), (7)) == (std::vector<long>({(long)9, (long)2})));
    assert(candidate((4), (5), (1)) == (std::vector<long>({(long)5, (long)0})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return a string containing space-delimited numbers starting from 0 upto n inclusive.
// >>> string_sequence((0))
// ("0")
// >>> string_sequence((5))
// ("0 1 2 3 4 5")
std::string string_sequence(long n) {

}
int main() {
    auto candidate = string_sequence;
    assert(candidate((0)) == ("0"));
    assert(candidate((3)) == ("0 1 2 3"));
    assert(candidate((10)) == ("0 1 2 3 4 5 6 7 8 9 10"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given two vectors operator, and operand. The first vector has basic algebra operations, and
// the second vector is a vector of integers. Use the two given vectors to build the algebric
// expression and return the evaluation of this expression.
// The basic algebra operations:
// Addition ( + )
// Subtraction ( - )
// Multiplication ( * )
// Floor division ( // )
// Exponentiation ( ** )
// Example:
// operator['+', '*', '-']
// vector = [2, 3, 4, 5]
// result = 2 + 3 * 4 - 5
// => result = 9
// Note:
// The length of operator vector is equal to the length of operand vector minus one.
// Operand is a vector of of non-negative integers.
// Operator vector has at least one operator, and operand vector has at least two operands.
long do_algebra(std::vector<std::string> op, std::vector<long> operand) {

}
int main() {
    auto candidate = do_algebra;
    assert(candidate((std::vector<std::string>({(std::string)"**", (std::string)"*", (std::string)"+"})), (std::vector<long>({(long)2, (long)3, (long)4, (long)5}))) == (37));
    assert(candidate((std::vector<std::string>({(std::string)"+", (std::string)"*", (std::string)"-"})), (std::vector<long>({(long)2, (long)3, (long)4, (long)5}))) == (9));
    assert(candidate((std::vector<std::string>({(std::string)"//", (std::string)"*"})), (std::vector<long>({(long)7, (long)3, (long)4}))) == (8));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a string s.
// if s[i] is a letter, reverse its case from lower to upper or vise versa,
// otherwise keep it as it is.
// If the string contains no letters, reverse the string.
// The function should return the resulted string.
// Examples
// >>> solve(("1234"))
// ("4321")
// >>> solve(("ab"))
// ("AB")
// >>> solve(("#a@C"))
// ("#A@c")
std::string solve(std::string s) {

}
int main() {
    auto candidate = solve;
    assert(candidate(("AsDf")) == ("aSdF"));
    assert(candidate(("1234")) == ("4321"));
    assert(candidate(("ab")) == ("AB"));
    assert(candidate(("#a@C")) == ("#A@c"));
    assert(candidate(("#AsdfW^45")) == ("#aSDFw^45"));
    assert(candidate(("#6@2")) == ("2@6#"));
    assert(candidate(("#$a^D")) == ("#$A^d"));
    assert(candidate(("#ccc")) == ("#CCC"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a string 'text', return its md5 hash equivalent string.
// If 'text' is an empty string, return None.
// >>> string_to_md5(("Hello world"))
// "3e25960a79dbc69b674cd4ec67a72c62"
std::optional<std::string> string_to_md5(std::string text) {

}
int main() {
    auto candidate = string_to_md5;
    assert(candidate(("Hello world")) == "3e25960a79dbc69b674cd4ec67a72c62");
    assert(candidate(("")) == std::nullopt);
    assert(candidate(("A B C")) == "0ef78513b0cb8cef12743f5aeb35f888");
    assert(candidate(("password")) == "5f4dcc3b5aa765d61d8327deb882cf99");
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given two positive integers a and b, return the even digits between a
// and b, in ascending order.
// For example:
// >>> generate_integers((2), (8))
// (std::vector<long>({(long)2, (long)4, (long)6, (long)8}))
// >>> generate_integers((8), (2))
// (std::vector<long>({(long)2, (long)4, (long)6, (long)8}))
// >>> generate_integers((10), (14))
// (std::vector<long>())
std::vector<long> generate_integers(long a, long b) {

}
int main() {
    auto candidate = generate_integers;
    assert(candidate((2), (10)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
    assert(candidate((10), (2)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
    assert(candidate((132), (2)) == (std::vector<long>({(long)2, (long)4, (long)6, (long)8})));
    assert(candidate((17), (89)) == (std::vector<long>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a string, find out how many distinct characters (regardless of case) does it consist of
// >>> count_distinct_characters(("xyzXYZ"))
// (3)
// >>> count_distinct_characters(("Jerry"))
// (4)
long count_distinct_characters(std::string string) {

}
int main() {
    auto candidate = count_distinct_characters;
    assert(candidate(("")) == (0));
    assert(candidate(("abcde")) == (5));
    assert(candidate(("abcdecadeCADE")) == (5));
    assert(candidate(("aaaaAAAAaaaa")) == (1));
    assert(candidate(("Jerry jERRY JeRRRY")) == (5));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Input to this function is a string representing musical notes in a special ASCII format.
// Your task is to parse this string and return vector of integers corresponding to how many beats does each
// not last.
// Here is a legend:
// 'o' - whole note, lasts four beats
// 'o|' - half note, lasts two beats
// '.|' - quater note, lasts one beat
// >>> parse_music(("o o| .| o| o| .| .| .| .| o o"))
// (std::vector<long>({(long)4, (long)2, (long)1, (long)2, (long)2, (long)1, (long)1, (long)1, (long)1, (long)4, (long)4}))
std::vector<long> parse_music(std::string music_string) {

}
int main() {
    auto candidate = parse_music;
    assert(candidate(("")) == (std::vector<long>()));
    assert(candidate(("o o o o")) == (std::vector<long>({(long)4, (long)4, (long)4, (long)4})));
    assert(candidate((".| .| .| .|")) == (std::vector<long>({(long)1, (long)1, (long)1, (long)1})));
    assert(candidate(("o| o| .| .| o o o o")) == (std::vector<long>({(long)2, (long)2, (long)1, (long)1, (long)4, (long)4, (long)4, (long)4})));
    assert(candidate(("o| .| o| .| o o| o o|")) == (std::vector<long>({(long)2, (long)1, (long)2, (long)1, (long)4, (long)2, (long)4, (long)2})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Find how many times a given substring can be found in the original string. Count overlaping cases.
// >>> how_many_times((""), ("a"))
// (0)
// >>> how_many_times(("aaa"), ("a"))
// (3)
// >>> how_many_times(("aaaa"), ("aa"))
// (3)
long how_many_times(std::string string, std::string substring) {

}
int main() {
    auto candidate = how_many_times;
    assert(candidate((""), ("x")) == (0));
    assert(candidate(("xyxyxyx"), ("x")) == (4));
    assert(candidate(("cacacacac"), ("cac")) == (4));
    assert(candidate(("john doe"), ("john")) == (1));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Input is a space-delimited string of numberals from 'zero' to 'nine'.
// Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
// Return the string with numbers sorted from smallest to largest
// >>> sort_numbers(("three one five"))
// ("one three five")
std::string sort_numbers(std::string numbers) {

}
int main() {
    auto candidate = sort_numbers;
    assert(candidate(("")) == (""));
    assert(candidate(("three")) == ("three"));
    assert(candidate(("three five nine")) == ("three five nine"));
    assert(candidate(("five zero four seven nine eight")) == ("zero four five seven eight nine"));
    assert(candidate(("six five four three two one zero")) == ("zero one two three four five six"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
// separate those group into separate strings and return the vector of those.
// Separate groups are balanced (each open brace is properly closed) and not nested within each other
// Ignore any spaces in the input string.
// >>> separate_paren_groups(("( ) (( )) (( )( ))"))
// (std::vector<std::string>({(std::string)"()", (std::string)"(())", (std::string)"(()())"}))
std::vector<std::string> separate_paren_groups(std::string paren_string) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// From a supplied vector of numbers (of length at least two) select and return two that are the closest to each
// other and return them in order (smaller number, larger number).
// >>> find_closest_elements((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.2f})))
// (std::make_tuple(2.0f, 2.2f))
// >>> find_closest_elements((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})))
// (std::make_tuple(2.0f, 2.0f))
std::tuple<float, float> find_closest_elements(std::vector<float> numbers) {

}
int main() {
    auto candidate = find_closest_elements;
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f}))) == (std::make_tuple(3.9f, 4.0f)));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f}))) == (std::make_tuple(5.0f, 5.9f)));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.2f}))) == (std::make_tuple(2.0f, 2.2f)));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f}))) == (std::make_tuple(2.0f, 2.0f)));
    assert(candidate((std::vector<float>({(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f}))) == (std::make_tuple(2.2f, 3.1f)));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given vector of numbers (of at least two elements), apply a linear transform to that vector,
// such that the smallest number will become 0 and the largest will become 1
// >>> rescale_to_unit((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f})))
// (std::vector<float>({(float)0.0f, (float)0.25f, (float)0.5f, (float)0.75f, (float)1.0f}))
std::vector<float> rescale_to_unit(std::vector<float> numbers) {

}
int main() {
    auto candidate = rescale_to_unit;
    assert(candidate((std::vector<float>({(float)2.0f, (float)49.9f}))) == (std::vector<float>({(float)0.0f, (float)1.0f})));
    assert(candidate((std::vector<float>({(float)100.0f, (float)49.9f}))) == (std::vector<float>({(float)1.0f, (float)0.0f})));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f}))) == (std::vector<float>({(float)0.0f, (float)0.25f, (float)0.5f, (float)0.75f, (float)1.0f})));
    assert(candidate((std::vector<float>({(float)2.0f, (float)1.0f, (float)5.0f, (float)3.0f, (float)4.0f}))) == (std::vector<float>({(float)0.25f, (float)0.0f, (float)1.0f, (float)0.5f, (float)0.75f})));
    assert(candidate((std::vector<float>({(float)12.0f, (float)11.0f, (float)15.0f, (float)13.0f, (float)14.0f}))) == (std::vector<float>({(float)0.25f, (float)0.0f, (float)1.0f, (float)0.5f, (float)0.75f})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Filter given vector of any cppthon values only for integers
// >>> filter_integers((std::vector<std::any>({(std::string)"a", (std::string)3.14f, (std::string)5})))
// (std::vector<long>({(long)5}))
// >>> filter_integers((std::vector<std::any>({1, 2, 3, "abc", std::map<long,long>(), std::vector<long>()})))
// (std::vector<long>({(long)1, (long)2, (long)3}))
std::vector<long> filter_integers(std::vector<std::any> values) {

}
int main() {
    auto candidate = filter_integers;
    assert(candidate((std::vector<std::any>())) == (std::vector<long>()));
    assert(candidate((std::vector<std::any>({4, std::map<long,long>(), std::vector<long>(), 23.2f, 9, "adasd"}))) == (std::vector<long>({(long)4, (long)9})));
    assert(candidate((std::vector<std::any>({3, "c", 3, 3, "a", "b"}))) == (std::vector<long>({(long)3, (long)3, (long)3})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return length of given string
// >>> string_length((""))
// (0)
// >>> string_length(("abc"))
// (3)
long string_length(std::string string) {

}
int main() {
    auto candidate = string_length;
    assert(candidate(("")) == (0));
    assert(candidate(("x")) == (1));
    assert(candidate(("asdasnakj")) == (9));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// For a given number n, find the largest number that divides n evenly, smaller than n
// >>> largest_divisor((15))
// (5)
long largest_divisor(long n) {

}
int main() {
    auto candidate = largest_divisor;
    assert(candidate((3)) == (1));
    assert(candidate((7)) == (1));
    assert(candidate((10)) == (5));
    assert(candidate((100)) == (50));
    assert(candidate((49)) == (7));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return vector of prime factors of given integer in the order from smallest to largest.
// Each of the factors should be vectored number of times corresponding to how many times it appeares in factorization.
// Input number should be equal to the product of all factors
// >>> factorize((8))
// (std::vector<long>({(long)2, (long)2, (long)2}))
// >>> factorize((25))
// (std::vector<long>({(long)5, (long)5}))
// >>> factorize((70))
// (std::vector<long>({(long)2, (long)5, (long)7}))
std::vector<long> factorize(long n) {

}
int main() {
    auto candidate = factorize;
    assert(candidate((2)) == (std::vector<long>({(long)2})));
    assert(candidate((4)) == (std::vector<long>({(long)2, (long)2})));
    assert(candidate((8)) == (std::vector<long>({(long)2, (long)2, (long)2})));
    assert(candidate((57)) == (std::vector<long>({(long)3, (long)19})));
    assert(candidate((3249)) == (std::vector<long>({(long)3, (long)3, (long)19, (long)19})));
    assert(candidate((185193)) == (std::vector<long>({(long)3, (long)3, (long)3, (long)19, (long)19, (long)19})));
    assert(candidate((20577)) == (std::vector<long>({(long)3, (long)19, (long)19, (long)19})));
    assert(candidate((18)) == (std::vector<long>({(long)2, (long)3, (long)3})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// From a vector of integers, remove all elements that occur more than once.
// Keep order of elements left the same as in the input.
// >>> remove_duplicates((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)4})))
// (std::vector<long>({(long)1, (long)3, (long)4}))
std::vector<long> remove_duplicates(std::vector<long> numbers) {

}
int main() {
    auto candidate = remove_duplicates;
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)2, (long)3, (long)4})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)4, (long)3, (long)5}))) == (std::vector<long>({(long)1, (long)4, (long)5})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
// >>> flip_case(("Hello"))
// ("hELLO")
std::string flip_case(std::string string) {

}
int main() {
    auto candidate = flip_case;
    assert(candidate(("")) == (""));
    assert(candidate(("Hello!")) == ("hELLO!"));
    assert(candidate(("These violent delights have violent ends")) == ("tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Concatenate vector of strings into a single string
// >>> concatenate((std::vector<std::string>()))
// ("")
// >>> concatenate((std::vector<std::string>({(std::string)"a", (std::string)"b", (std::string)"c"})))
// ("abc")
std::string concatenate(std::vector<std::string> strings) {

}
int main() {
    auto candidate = concatenate;
    assert(candidate((std::vector<std::string>())) == (""));
    assert(candidate((std::vector<std::string>({(std::string)"x", (std::string)"y", (std::string)"z"}))) == ("xyz"));
    assert(candidate((std::vector<std::string>({(std::string)"x", (std::string)"y", (std::string)"z", (std::string)"w", (std::string)"k"}))) == ("xyzwk"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Filter an input vector of strings only for ones that start with a given prefix.
// >>> filter_by_prefix((std::vector<std::string>()), ("a"))
// (std::vector<std::string>())
// >>> filter_by_prefix((std::vector<std::string>({(std::string)"abc", (std::string)"bcd", (std::string)"cde", (std::string)"array"})), ("a"))
// (std::vector<std::string>({(std::string)"abc", (std::string)"array"}))
std::vector<std::string> filter_by_prefix(std::vector<std::string> strings, std::string prefix) {

}
int main() {
    auto candidate = filter_by_prefix;
    assert(candidate((std::vector<std::string>()), ("john")) == (std::vector<std::string>()));
    assert(candidate((std::vector<std::string>({(std::string)"xxx", (std::string)"asd", (std::string)"xxy", (std::string)"john doe", (std::string)"xxxAAA", (std::string)"xxx"})), ("xxx")) == (std::vector<std::string>({(std::string)"xxx", (std::string)"xxxAAA", (std::string)"xxx"})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a positive floating point number, it can be decomposed into
// and integer part (largest integer smaller than given number) and decimals
// (leftover part always smaller than 1).
// Return the decimal part of the number.
// >>> truncate_number((3.5f))
// (0.5f)
float truncate_number(float number) {

}
int main() {
    auto candidate = truncate_number;
    assert(candidate((3.5f)) == (0.5f));
    assert(candidate((1.25f)) == (0.25f));
    assert(candidate((123.0f)) == (0.0f));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return only positive numbers in the vector.
// >>> get_positive((std::vector<long>({(long)-1, (long)2, (long)-4, (long)5, (long)6})))
// (std::vector<long>({(long)2, (long)5, (long)6}))
// >>> get_positive((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)9, (long)0, (long)123, (long)1, (long)-10})))
// (std::vector<long>({(long)5, (long)3, (long)2, (long)3, (long)9, (long)123, (long)1}))
std::vector<long> get_positive(std::vector<long> l) {

}
int main() {
    auto candidate = get_positive;
    assert(candidate((std::vector<long>({(long)-1, (long)-2, (long)4, (long)5, (long)6}))) == (std::vector<long>({(long)4, (long)5, (long)6})));
    assert(candidate((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123, (long)1, (long)-10}))) == (std::vector<long>({(long)5, (long)3, (long)2, (long)3, (long)3, (long)9, (long)123, (long)1})));
    assert(candidate((std::vector<long>({(long)-1, (long)-2}))) == (std::vector<long>()));
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return true if a given number is prime, and false otherwise.
// >>> is_prime((6))
// (false)
// >>> is_prime((101))
// (true)
// >>> is_prime((11))
// (true)
// >>> is_prime((13441))
// (true)
// >>> is_prime((61))
// (true)
// >>> is_prime((4))
// (false)
// >>> is_prime((1))
// (false)
bool is_prime(long n) {

}
int main() {
    auto candidate = is_prime;
    assert(candidate((6)) == (false));
    assert(candidate((101)) == (true));
    assert(candidate((11)) == (true));
    assert(candidate((13441)) == (true));
    assert(candidate((61)) == (true));
    assert(candidate((4)) == (false));
    assert(candidate((1)) == (false));
    assert(candidate((5)) == (true));
    assert(candidate((11)) == (true));
    assert(candidate((17)) == (true));
    assert(candidate((85)) == (false));
    assert(candidate((77)) == (false));
    assert(candidate((255379)) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// This function takes a vector l and returns a vector l' such that
// l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
// to the values of the corresponding indicies of l, but sorted.
// >>> sort_third((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)1, (long)2, (long)3}))
// >>> sort_third((std::vector<long>({(long)5, (long)6, (long)3, (long)4, (long)8, (long)9, (long)2})))
// (std::vector<long>({(long)2, (long)6, (long)3, (long)4, (long)8, (long)9, (long)5}))
std::vector<long> sort_third(std::vector<long> l) {

}
int main() {
    auto candidate = sort_third;
    assert(candidate((std::vector<long>({(long)5, (long)6, (long)3, (long)4, (long)8, (long)9, (long)2}))) == (std::vector<long>({(long)2, (long)6, (long)3, (long)4, (long)8, (long)9, (long)5})));
    assert(candidate((std::vector<long>({(long)5, (long)8, (long)3, (long)4, (long)6, (long)9, (long)2}))) == (std::vector<long>({(long)2, (long)8, (long)3, (long)4, (long)6, (long)9, (long)5})));
    assert(candidate((std::vector<long>({(long)5, (long)6, (long)9, (long)4, (long)8, (long)3, (long)2}))) == (std::vector<long>({(long)2, (long)6, (long)9, (long)4, (long)8, (long)3, (long)5})));
    assert(candidate((std::vector<long>({(long)5, (long)6, (long)3, (long)4, (long)8, (long)9, (long)2, (long)1}))) == (std::vector<long>({(long)2, (long)6, (long)3, (long)4, (long)8, (long)9, (long)5, (long)1})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return sorted unique elements in a vector
// >>> unique((std::vector<long>({(long)5, (long)3, (long)5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123})))
// (std::vector<long>({(long)0, (long)2, (long)3, (long)5, (long)9, (long)123}))
std::vector<long> unique(std::vector<long> l) {

}
int main() {
    auto candidate = unique;
    assert(candidate((std::vector<long>({(long)5, (long)3, (long)5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123}))) == (std::vector<long>({(long)0, (long)2, (long)3, (long)5, (long)9, (long)123})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return maximum element in the vector.
// >>> max_element((std::vector<long>({(long)1, (long)2, (long)3})))
// (3)
// >>> max_element((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)9, (long)0, (long)123, (long)1, (long)-10})))
// (123)
long max_element(std::vector<long> l) {

}
int main() {
    auto candidate = max_element;
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (3));
    assert(candidate((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)9, (long)0, (long)124, (long)1, (long)-10}))) == (124));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
// >>> fizz_buzz((50))
// (0)
// >>> fizz_buzz((78))
// (2)
// >>> fizz_buzz((79))
// (3)
long fizz_buzz(long n) {

}
int main() {
    auto candidate = fizz_buzz;
    assert(candidate((50)) == (0));
    assert(candidate((78)) == (2));
    assert(candidate((79)) == (3));
    assert(candidate((100)) == (3));
    assert(candidate((200)) == (6));
    assert(candidate((4000)) == (192));
    assert(candidate((10000)) == (639));
    assert(candidate((100000)) == (8026));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// This function takes a vector l and returns a vector l' such that
// l' is identical to l in the odd indicies, while its values at the even indicies are equal
// to the values of the even indicies of l, but sorted.
// >>> sort_even((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)1, (long)2, (long)3}))
// >>> sort_even((std::vector<long>({(long)5, (long)6, (long)3, (long)4})))
// (std::vector<long>({(long)3, (long)6, (long)5, (long)4}))
std::vector<long> sort_even(std::vector<long> l) {

}
int main() {
    auto candidate = sort_even;
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (std::vector<long>({(long)1, (long)2, (long)3})));
    assert(candidate((std::vector<long>({(long)5, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)9, (long)0, (long)123, (long)1, (long)-10}))) == (std::vector<long>({(long)-10, (long)3, (long)-5, (long)2, (long)-3, (long)3, (long)5, (long)0, (long)9, (long)1, (long)123})));
    assert(candidate((std::vector<long>({(long)5, (long)8, (long)-12, (long)4, (long)23, (long)2, (long)3, (long)11, (long)12, (long)-10}))) == (std::vector<long>({(long)-12, (long)8, (long)3, (long)4, (long)5, (long)2, (long)12, (long)11, (long)23, (long)-10})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// prime_fib returns n-th number that is a Fibonacci number and it's also prime.
// >>> prime_fib((1))
// (2)
// >>> prime_fib((2))
// (3)
// >>> prime_fib((3))
// (5)
// >>> prime_fib((4))
// (13)
// >>> prime_fib((5))
// (89)
long prime_fib(long n) {

}
int main() {
    auto candidate = prime_fib;
    assert(candidate((1)) == (2));
    assert(candidate((2)) == (3));
    assert(candidate((3)) == (5));
    assert(candidate((4)) == (13));
    assert(candidate((5)) == (89));
    assert(candidate((6)) == (233));
    assert(candidate((7)) == (1597));
    assert(candidate((8)) == (28657));
    assert(candidate((9)) == (514229));
    assert(candidate((10)) == (433494437));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You're given a vector of deposit and withdrawal operations on a bank account that starts with
// zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
// at that point function should return true. Otherwise it should return false.
// >>> below_zero((std::vector<long>({(long)1, (long)2, (long)3})))
// (false)
// >>> below_zero((std::vector<long>({(long)1, (long)2, (long)-4, (long)5})))
// (true)
bool below_zero(std::vector<long> operations) {

}
int main() {
    auto candidate = below_zero;
    assert(candidate((std::vector<long>())) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)-3, (long)1, (long)2, (long)-3}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)-4, (long)5, (long)6}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)-1, (long)2, (long)-2, (long)5, (long)-5, (long)4, (long)-4}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)-1, (long)2, (long)-2, (long)5, (long)-5, (long)4, (long)-5}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)-2, (long)2, (long)-2, (long)5, (long)-5, (long)4, (long)-4}))) == (true));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// triples_sum_to_zero takes a vector of integers as an input.
// it returns true if there are three distinct elements in the vector that
// sum to zero, and false otherwise.
// >>> triples_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)5, (long)0})))
// (false)
// >>> triples_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)-2, (long)1})))
// (true)
// >>> triples_sum_to_zero((std::vector<long>({(long)1, (long)2, (long)3, (long)7})))
// (false)
// >>> triples_sum_to_zero((std::vector<long>({(long)2, (long)4, (long)-5, (long)3, (long)9, (long)7})))
// (true)
// >>> triples_sum_to_zero((std::vector<long>({(long)1})))
// (false)
bool triples_sum_to_zero(std::vector<long> l) {

}
int main() {
    auto candidate = triples_sum_to_zero;
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)0}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)-1}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)-2, (long)1}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)7}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)5, (long)7}))) == (false));
    assert(candidate((std::vector<long>({(long)2, (long)4, (long)-5, (long)3, (long)9, (long)7}))) == (true));
    assert(candidate((std::vector<long>({(long)1}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)-100}))) == (false));
    assert(candidate((std::vector<long>({(long)100, (long)3, (long)5, (long)-100}))) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Imagine a road that's a perfectly straight infinitely long line.
// n cars are driving left to right;  simultaneously, a different set of n cars
// are driving right to left.   The two sets of cars start out being very far from
// each other.  All cars move in the same speed.  Two cars are said to collide
// when a car that's moving left to right hits a car that's moving right to left.
// However, the cars are infinitely sturdy and strong; as a result, they continue moving
// in their trajectory as if they did not collide.
// This function outputs the number of such collisions.
long car_race_collision(long n) {

}
int main() {
    auto candidate = car_race_collision;
    assert(candidate((2)) == (4));
    assert(candidate((3)) == (9));
    assert(candidate((4)) == (16));
    assert(candidate((8)) == (64));
    assert(candidate((10)) == (100));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return vector with elements incremented by 1.
// >>> incr_list((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)2, (long)3, (long)4}))
// >>> incr_list((std::vector<long>({(long)5, (long)3, (long)5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123})))
// (std::vector<long>({(long)6, (long)4, (long)6, (long)3, (long)4, (long)4, (long)10, (long)1, (long)124}))
std::vector<long> incr_list(std::vector<long> l) {

}
int main() {
    auto candidate = incr_list;
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)3, (long)2, (long)1}))) == (std::vector<long>({(long)4, (long)3, (long)2})));
    assert(candidate((std::vector<long>({(long)5, (long)2, (long)5, (long)2, (long)3, (long)3, (long)9, (long)0, (long)123}))) == (std::vector<long>({(long)6, (long)3, (long)6, (long)3, (long)4, (long)4, (long)10, (long)1, (long)124})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// pairs_sum_to_zero takes a vector of integers as an input.
// it returns true if there are two distinct elements in the vector that
// sum to zero, and false otherwise.
// >>> pairs_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)5, (long)0})))
// (false)
// >>> pairs_sum_to_zero((std::vector<long>({(long)1, (long)3, (long)-2, (long)1})))
// (false)
// >>> pairs_sum_to_zero((std::vector<long>({(long)1, (long)2, (long)3, (long)7})))
// (false)
// >>> pairs_sum_to_zero((std::vector<long>({(long)2, (long)4, (long)-5, (long)3, (long)5, (long)7})))
// (true)
// >>> pairs_sum_to_zero((std::vector<long>({(long)1})))
// (false)
bool pairs_sum_to_zero(std::vector<long> l) {

}
int main() {
    auto candidate = pairs_sum_to_zero;
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)5, (long)0}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)-2, (long)1}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)7}))) == (false));
    assert(candidate((std::vector<long>({(long)2, (long)4, (long)-5, (long)3, (long)5, (long)7}))) == (true));
    assert(candidate((std::vector<long>({(long)1}))) == (false));
    assert(candidate((std::vector<long>({(long)-3, (long)9, (long)-1, (long)3, (long)2, (long)30}))) == (true));
    assert(candidate((std::vector<long>({(long)-3, (long)9, (long)-1, (long)3, (long)2, (long)31}))) == (true));
    assert(candidate((std::vector<long>({(long)-3, (long)9, (long)-1, (long)4, (long)2, (long)30}))) == (false));
    assert(candidate((std::vector<long>({(long)-3, (long)9, (long)-1, (long)4, (long)2, (long)31}))) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Change numerical base of input number x to base.
// return string representation after the conversion.
// base numbers are less than 10.
// >>> change_base((8), (3))
// ("22")
// >>> change_base((8), (2))
// ("1000")
// >>> change_base((7), (2))
// ("111")
std::string change_base(long x, long base) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given length of a side and high return area for a triangle.
// >>> triangle_area((5), (3))
// (7.5f)
float triangle_area(long a, long h) {

}
int main() {
    auto candidate = triangle_area;
    assert(candidate((5), (3)) == (7.5f));
    assert(candidate((2), (2)) == (2.0f));
    assert(candidate((10), (8)) == (40.0f));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fib4(0) -> 0
// fib4(1) -> 0
// fib4(2) -> 2
// fib4(3) -> 0
// fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
// Please write a function to efficiently compute the n-th element of the fib4 number sequence.  Do not use recursion.
// >>> fib4((5))
// (4)
// >>> fib4((6))
// (8)
// >>> fib4((7))
// (14)
long fib4(long n) {

}
int main() {
    auto candidate = fib4;
    assert(candidate((5)) == (4));
    assert(candidate((8)) == (28));
    assert(candidate((10)) == (104));
    assert(candidate((12)) == (386));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return median of elements in the vector l.
// >>> median((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5})))
// (float(3))
// >>> median((std::vector<long>({(long)-10, (long)4, (long)6, (long)1000, (long)10, (long)20})))
// (15.0f)
float median(std::vector<long> l) {

}
int main() {
    auto candidate = median;
    assert(candidate((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5}))) == (float(3)));
    assert(candidate((std::vector<long>({(long)-10, (long)4, (long)6, (long)1000, (long)10, (long)20}))) == (8.0f));
    assert(candidate((std::vector<long>({(long)5}))) == (float(5)));
    assert(candidate((std::vector<long>({(long)6, (long)5}))) == (5.5f));
    assert(candidate((std::vector<long>({(long)8, (long)1, (long)3, (long)9, (long)9, (long)2, (long)7}))) == (float(7)));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Checks if given string is a palindrome
// >>> is_palindrome((""))
// (true)
// >>> is_palindrome(("aba"))
// (true)
// >>> is_palindrome(("aaaaa"))
// (true)
// >>> is_palindrome(("zbcd"))
// (false)
bool is_palindrome(std::string text) {

}
int main() {
    auto candidate = is_palindrome;
    assert(candidate(("")) == (true));
    assert(candidate(("aba")) == (true));
    assert(candidate(("aaaaa")) == (true));
    assert(candidate(("zbcd")) == (false));
    assert(candidate(("xywyx")) == (true));
    assert(candidate(("xywyz")) == (false));
    assert(candidate(("xywzx")) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return 2^n modulo p (be aware of numerics).
// >>> modp((3), (5))
// (3)
// >>> modp((1101), (101))
// (2)
// >>> modp((0), (101))
// (1)
// >>> modp((3), (11))
// (8)
// >>> modp((100), (101))
// (1)
long modp(long n, long p) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// For a given vector of input numbers, calculate Mean Absolute Deviation
// around the mean of this dataset.
// Mean Absolute Deviation is the average absolute difference between each
// element and a centerpoint (mean in this case):
// MAD = average | x - x_mean |
// >>> mean_absolute_deviation((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f})))
// (1.0f)
float mean_absolute_deviation(std::vector<float> numbers) {

}
int main() {
    auto candidate = mean_absolute_deviation;
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f}))) == (0.5f));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f}))) == (1.0f));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f}))) == (1.2f));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// remove_vowels is a function that takes string and returns string without vowels.
// >>> remove_vowels((""))
// ("")
// >>> remove_vowels(("abcdef"))
// ("bcdf")
// >>> remove_vowels(("aaaaa"))
// ("")
// >>> remove_vowels(("aaBAA"))
// ("B")
// >>> remove_vowels(("zbcd"))
// ("zbcd")
std::string remove_vowels(std::string text) {

}
int main() {
    auto candidate = remove_vowels;
    assert(candidate(("")) == (""));
    assert(candidate(("abcdef\nghijklm")) == ("bcdf\nghjklm"));
    assert(candidate(("fedcba")) == ("fdcb"));
    assert(candidate(("eeeee")) == (""));
    assert(candidate(("acBAA")) == ("cB"));
    assert(candidate(("EcBOO")) == ("cB"));
    assert(candidate(("ybcd")) == ("ybcd"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return true if all numbers in the vector l are below threshold t.
// >>> below_threshold((std::vector<long>({(long)1, (long)2, (long)4, (long)10})), (100))
// (true)
// >>> below_threshold((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (5))
// (false)
bool below_threshold(std::vector<long> l, long t) {

}
int main() {
    auto candidate = below_threshold;
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)10})), (100)) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (5)) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (21)) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10})), (22)) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)8, (long)4, (long)10})), (11)) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)8, (long)4, (long)10})), (10)) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Add two numbers x and y
// >>> add((2), (3))
// (5)
// >>> add((5), (7))
// (12)
long add(long x, long y) {

}
int main() {
    auto candidate = add;
    assert(candidate((0), (1)) == (1));
    assert(candidate((1), (0)) == (1));
    assert(candidate((2), (3)) == (5));
    assert(candidate((5), (7)) == (12));
    assert(candidate((7), (5)) == (12));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Check if two words have the same characters.
// >>> same_chars(("eabcdzzzz"), ("dddzzzzzzzddeddabc"))
// (true)
// >>> same_chars(("abcd"), ("dddddddabc"))
// (true)
// >>> same_chars(("dddddddabc"), ("abcd"))
// (true)
// >>> same_chars(("eabcd"), ("dddddddabc"))
// (false)
// >>> same_chars(("abcd"), ("dddddddabce"))
// (false)
// >>> same_chars(("eabcdzzzz"), ("dddzzzzzzzddddabc"))
// (false)
bool same_chars(std::string s0, std::string s1) {

}
int main() {
    auto candidate = same_chars;
    assert(candidate(("eabcdzzzz"), ("dddzzzzzzzddeddabc")) == (true));
    assert(candidate(("abcd"), ("dddddddabc")) == (true));
    assert(candidate(("dddddddabc"), ("abcd")) == (true));
    assert(candidate(("eabcd"), ("dddddddabc")) == (false));
    assert(candidate(("abcd"), ("dddddddabcf")) == (false));
    assert(candidate(("eabcdzzzz"), ("dddzzzzzzzddddabc")) == (false));
    assert(candidate(("aabb"), ("aaccc")) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return n-th Fibonacci number.
// >>> fib((10))
// (55)
// >>> fib((1))
// (1)
// >>> fib((8))
// (21)
long fib(long n) {

}
int main() {
    auto candidate = fib;
    assert(candidate((10)) == (55));
    assert(candidate((1)) == (1));
    assert(candidate((8)) == (21));
    assert(candidate((11)) == (89));
    assert(candidate((12)) == (144));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// brackets is a string of "<" and ">".
// return true if every opening bracket has a corresponding closing bracket.
// >>> correct_bracketing(("<"))
// (false)
// >>> correct_bracketing(("<>"))
// (true)
// >>> correct_bracketing(("<<><>>"))
// (true)
// >>> correct_bracketing(("><<>"))
// (false)
bool correct_bracketing(std::string brackets) {

}
int main() {
    auto candidate = correct_bracketing;
    assert(candidate(("<>")) == (true));
    assert(candidate(("<<><>>")) == (true));
    assert(candidate(("<><><<><>><>")) == (true));
    assert(candidate(("<><><<<><><>><>><<><><<>>>")) == (true));
    assert(candidate(("<<<><>>>>")) == (false));
    assert(candidate(("><<>")) == (false));
    assert(candidate(("<")) == (false));
    assert(candidate(("<<<<")) == (false));
    assert(candidate((">")) == (false));
    assert(candidate(("<<>")) == (false));
    assert(candidate(("<><><<><>><>><<>")) == (false));
    assert(candidate(("<><><<><>><>>><>")) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return true is vector elements are monotonically increasing or decreasing.
// >>> monotonic((std::vector<long>({(long)1, (long)2, (long)4, (long)20})))
// (true)
// >>> monotonic((std::vector<long>({(long)1, (long)20, (long)4, (long)10})))
// (false)
// >>> monotonic((std::vector<long>({(long)4, (long)1, (long)0, (long)-10})))
// (true)
bool monotonic(std::vector<long> l) {

}
int main() {
    auto candidate = monotonic;
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)10}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)4, (long)20}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)20, (long)4, (long)10}))) == (false));
    assert(candidate((std::vector<long>({(long)4, (long)1, (long)0, (long)-10}))) == (true));
    assert(candidate((std::vector<long>({(long)4, (long)1, (long)1, (long)0}))) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)5, (long)60}))) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)60}))) == (true));
    assert(candidate((std::vector<long>({(long)9, (long)9, (long)9, (long)9}))) == (true));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return sorted unique common elements for two vectors.
// >>> common((std::vector<long>({(long)1, (long)4, (long)3, (long)34, (long)653, (long)2, (long)5})), (std::vector<long>({(long)5, (long)7, (long)1, (long)5, (long)9, (long)653, (long)121})))
// (std::vector<long>({(long)1, (long)5, (long)653}))
// >>> common((std::vector<long>({(long)5, (long)3, (long)2, (long)8})), (std::vector<long>({(long)3, (long)2})))
// (std::vector<long>({(long)2, (long)3}))
std::vector<long> common(std::vector<long> l1, std::vector<long> l2) {

}
int main() {
    auto candidate = common;
    assert(candidate((std::vector<long>({(long)1, (long)4, (long)3, (long)34, (long)653, (long)2, (long)5})), (std::vector<long>({(long)5, (long)7, (long)1, (long)5, (long)9, (long)653, (long)121}))) == (std::vector<long>({(long)1, (long)5, (long)653})));
    assert(candidate((std::vector<long>({(long)5, (long)3, (long)2, (long)8})), (std::vector<long>({(long)3, (long)2}))) == (std::vector<long>({(long)2, (long)3})));
    assert(candidate((std::vector<long>({(long)4, (long)3, (long)2, (long)8})), (std::vector<long>({(long)3, (long)2, (long)4}))) == (std::vector<long>({(long)2, (long)3, (long)4})));
    assert(candidate((std::vector<long>({(long)4, (long)3, (long)2, (long)8})), (std::vector<long>())) == (std::vector<long>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Return the largest prime factor of n. Assume n > 1 and is not a prime.
// >>> largest_prime_factor((13195))
// (29)
// >>> largest_prime_factor((2048))
// (2)
long largest_prime_factor(long n) {

}
int main() {
    auto candidate = largest_prime_factor;
    assert(candidate((15)) == (5));
    assert(candidate((27)) == (3));
    assert(candidate((63)) == (7));
    assert(candidate((330)) == (11));
    assert(candidate((13195)) == (29));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Insert a number 'delimeter' between every two consecutive elements of input vector `numbers'
// >>> intersperse((std::vector<long>()), (4))
// (std::vector<long>())
// >>> intersperse((std::vector<long>({(long)1, (long)2, (long)3})), (4))
// (std::vector<long>({(long)1, (long)4, (long)2, (long)4, (long)3}))
std::vector<long> intersperse(std::vector<long> numbers, long delimeter) {

}
int main() {
    auto candidate = intersperse;
    assert(candidate((std::vector<long>()), (7)) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)5, (long)6, (long)3, (long)2})), (8)) == (std::vector<long>({(long)5, (long)8, (long)6, (long)8, (long)3, (long)8, (long)2})));
    assert(candidate((std::vector<long>({(long)2, (long)2, (long)2})), (2)) == (std::vector<long>({(long)2, (long)2, (long)2, (long)2, (long)2})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// sum_to_n is a function that sums numbers from 1 to n.
// >>> sum_to_n((30))
// (465)
// >>> sum_to_n((100))
// (5050)
// >>> sum_to_n((5))
// (15)
// >>> sum_to_n((10))
// (55)
// >>> sum_to_n((1))
// (1)
long sum_to_n(long n) {

}
int main() {
    auto candidate = sum_to_n;
    assert(candidate((1)) == (1));
    assert(candidate((6)) == (21));
    assert(candidate((11)) == (66));
    assert(candidate((30)) == (465));
    assert(candidate((100)) == (5050));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// brackets is a string of "(" and ")".
// return true if every opening bracket has a corresponding closing bracket.
// >>> correct_bracketing(("("))
// (false)
// >>> correct_bracketing(("()"))
// (true)
// >>> correct_bracketing(("(()())"))
// (true)
// >>> correct_bracketing((")(()"))
// (false)
bool correct_bracketing(std::string brackets) {

}
int main() {
    auto candidate = correct_bracketing;
    assert(candidate(("()")) == (true));
    assert(candidate(("(()())")) == (true));
    assert(candidate(("()()(()())()")) == (true));
    assert(candidate(("()()((()()())())(()()(()))")) == (true));
    assert(candidate(("((()())))")) == (false));
    assert(candidate((")(()")) == (false));
    assert(candidate(("(")) == (false));
    assert(candidate(("((((")) == (false));
    assert(candidate((")")) == (false));
    assert(candidate(("(()")) == (false));
    assert(candidate(("()()(()())())(()")) == (false));
    assert(candidate(("()()(()())()))()")) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// xs represent coefficients of a polynomial.
// xs[0] + xs[1] * x + xs[2] * x^2 + ....
// Return derivative of this polynomial in the same form.
// >>> derivative((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5})))
// (std::vector<long>({(long)1, (long)4, (long)12, (long)20}))
// >>> derivative((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)2, (long)6}))
std::vector<long> derivative(std::vector<long> xs) {

}
int main() {
    auto candidate = derivative;
    assert(candidate((std::vector<long>({(long)3, (long)1, (long)2, (long)4, (long)5}))) == (std::vector<long>({(long)1, (long)4, (long)12, (long)20})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (std::vector<long>({(long)2, (long)6})));
    assert(candidate((std::vector<long>({(long)3, (long)2, (long)1}))) == (std::vector<long>({(long)2, (long)2})));
    assert(candidate((std::vector<long>({(long)3, (long)2, (long)1, (long)0, (long)4}))) == (std::vector<long>({(long)2, (long)2, (long)0, (long)16})));
    assert(candidate((std::vector<long>({(long)1}))) == (std::vector<long>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
// fibfib(0) == 0
// fibfib(1) == 0
// fibfib(2) == 1
// fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
// Please write a function to efficiently compute the n-th element of the fibfib number sequence.
// >>> fibfib((1))
// (0)
// >>> fibfib((5))
// (4)
// >>> fibfib((8))
// (24)
long fibfib(long n) {

}
int main() {
    auto candidate = fibfib;
    assert(candidate((2)) == (1));
    assert(candidate((1)) == (0));
    assert(candidate((5)) == (4));
    assert(candidate((8)) == (24));
    assert(candidate((10)) == (81));
    assert(candidate((12)) == (274));
    assert(candidate((14)) == (927));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function vowels_count which takes a string representing
// a word as input and returns the number of vowels in the string.
// Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
// vowel, but only when it is at the end of the given word.
// Example:
// >>> vowels_count(("abcde"))
// (2)
// >>> vowels_count(("ACEDY"))
// (3)
long vowels_count(std::string s) {

}
int main() {
    auto candidate = vowels_count;
    assert(candidate(("abcde")) == (2));
    assert(candidate(("Alone")) == (3));
    assert(candidate(("key")) == (2));
    assert(candidate(("bye")) == (1));
    assert(candidate(("keY")) == (2));
    assert(candidate(("bYe")) == (1));
    assert(candidate(("ACEDY")) == (3));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Circular shift the digits of the integer x, shift the digits right by shift
// and return the result as a string.
// If shift > number of digits, return digits reversed.
// >>> circular_shift((12), (1))
// ("21")
// >>> circular_shift((12), (2))
// ("12")
std::string circular_shift(long x, long shift) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Task
// Write a function that takes a string as input and returns the sum of the upper characters only'
// ASCII codes.
// Examples:
// >>> digitSum((""))
// (0)
// >>> digitSum(("abAB"))
// (131)
// >>> digitSum(("abcCd"))
// (67)
// >>> digitSum(("helloE"))
// (69)
// >>> digitSum(("woArBld"))
// (131)
// >>> digitSum(("aAaaaXa"))
// (153)
long digitSum(std::string s) {

}
int main() {
    auto candidate = digitSum;
    assert(candidate(("")) == (0));
    assert(candidate(("abAB")) == (131));
    assert(candidate(("abcCd")) == (67));
    assert(candidate(("helloE")) == (69));
    assert(candidate(("woArBld")) == (131));
    assert(candidate(("aAaaaXa")) == (153));
    assert(candidate((" How are yOu?")) == (151));
    assert(candidate(("You arE Very Smart")) == (327));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// In this task, you will be given a string that represents a number of apples and oranges
// that are distributed in a basket of fruit this basket contains
// apples, oranges, and mango fruits. Given the string that represents the total number of
// the oranges and apples and an integer that represent the total number of the fruits
// in the basket return the number of the mango fruits in the basket.
// for examble:
// >>> fruit_distribution(("5 apples and 6 oranges"), (19))
// (8)
// >>> fruit_distribution(("0 apples and 1 oranges"), (3))
// (2)
// >>> fruit_distribution(("2 apples and 3 oranges"), (100))
// (95)
// >>> fruit_distribution(("100 apples and 1 oranges"), (120))
// (19)
long fruit_distribution(std::string s, long n) {

}
int main() {
    auto candidate = fruit_distribution;
    assert(candidate(("5 apples and 6 oranges"), (19)) == (8));
    assert(candidate(("5 apples and 6 oranges"), (21)) == (10));
    assert(candidate(("0 apples and 1 oranges"), (3)) == (2));
    assert(candidate(("1 apples and 0 oranges"), (3)) == (2));
    assert(candidate(("2 apples and 3 oranges"), (100)) == (95));
    assert(candidate(("2 apples and 3 oranges"), (5)) == (0));
    assert(candidate(("1 apples and 100 oranges"), (120)) == (19));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// "Given a vector representing a branch of a tree that has non-negative integer nodes
// your task is to pluck one of the nodes and return it.
// The plucked node should be the node with the smallest even value.
// If multiple nodes with the same smallest even value are found return the node that has smallest index.
// The plucked node should be returned in a vector, [ smalest_value, its index ],
// If there are no even values or the given vector is empty, return [].
// Example 1:
// >>> pluck((std::vector<long>({(long)4, (long)2, (long)3})))
// (std::vector<long>({(long)2, (long)1}))
// Explanation: 2 has the smallest even value, and 2 has the smallest index.
// Example 2:
// >>> pluck((std::vector<long>({(long)1, (long)2, (long)3})))
// (std::vector<long>({(long)2, (long)1}))
// Explanation: 2 has the smallest even value, and 2 has the smallest index.
// Example 3:
// >>> pluck((std::vector<long>()))
// (std::vector<long>())
// Example 4:
// >>> pluck((std::vector<long>({(long)5, (long)0, (long)3, (long)0, (long)4, (long)2})))
// (std::vector<long>({(long)0, (long)1}))
// Explanation: 0 is the smallest value, but  there are two zeros,
// so we will choose the first zero, which has the smallest index.
// Constraints:
// * 1 <= nodes.length <= 10000
// * 0 <= node.value
std::vector<long> pluck(std::vector<long> arr) {

}
int main() {
    auto candidate = pluck;
    assert(candidate((std::vector<long>({(long)4, (long)2, (long)3}))) == (std::vector<long>({(long)2, (long)1})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3}))) == (std::vector<long>({(long)2, (long)1})));
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)5, (long)0, (long)3, (long)0, (long)4, (long)2}))) == (std::vector<long>({(long)0, (long)1})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)0, (long)5, (long)3}))) == (std::vector<long>({(long)0, (long)3})));
    assert(candidate((std::vector<long>({(long)5, (long)4, (long)8, (long)4, (long)8}))) == (std::vector<long>({(long)4, (long)1})));
    assert(candidate((std::vector<long>({(long)7, (long)6, (long)7, (long)1}))) == (std::vector<long>({(long)6, (long)1})));
    assert(candidate((std::vector<long>({(long)7, (long)9, (long)7, (long)1}))) == (std::vector<long>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a non-empty vector of positive integers. Return the greatest integer that is greater than
// zero, and has a frequency greater than or equal to the value of the integer itself.
// The frequency of an integer is the number of times it appears in the vector.
// If no such a value exist, return -1.
// Examples:
// >>> search((std::vector<long>({(long)4, (long)1, (long)2, (long)2, (long)3, (long)1})))
// (2)
// >>> search((std::vector<long>({(long)1, (long)2, (long)2, (long)3, (long)3, (long)3, (long)4, (long)4, (long)4})))
// (3)
// >>> search((std::vector<long>({(long)5, (long)5, (long)4, (long)4, (long)4})))
// (-1)
long search(std::vector<long> lst) {

}
int main() {
    auto candidate = search;
    assert(candidate((std::vector<long>({(long)5, (long)5, (long)5, (long)5, (long)1}))) == (1));
    assert(candidate((std::vector<long>({(long)4, (long)1, (long)4, (long)1, (long)4, (long)4}))) == (4));
    assert(candidate((std::vector<long>({(long)3, (long)3}))) == (-1));
    assert(candidate((std::vector<long>({(long)8, (long)8, (long)8, (long)8, (long)8, (long)8, (long)8, (long)8}))) == (8));
    assert(candidate((std::vector<long>({(long)2, (long)3, (long)3, (long)2, (long)2}))) == (2));
    assert(candidate((std::vector<long>({(long)2, (long)7, (long)8, (long)8, (long)4, (long)8, (long)7, (long)3, (long)9, (long)6, (long)5, (long)10, (long)4, (long)3, (long)6, (long)7, (long)1, (long)7, (long)4, (long)10, (long)8, (long)1}))) == (1));
    assert(candidate((std::vector<long>({(long)3, (long)2, (long)8, (long)2}))) == (2));
    assert(candidate((std::vector<long>({(long)6, (long)7, (long)1, (long)8, (long)8, (long)10, (long)5, (long)8, (long)5, (long)3, (long)10}))) == (1));
    assert(candidate((std::vector<long>({(long)8, (long)8, (long)3, (long)6, (long)5, (long)6, (long)4}))) == (-1));
    assert(candidate((std::vector<long>({(long)6, (long)9, (long)6, (long)7, (long)1, (long)4, (long)7, (long)1, (long)8, (long)8, (long)9, (long)8, (long)10, (long)10, (long)8, (long)4, (long)10, (long)4, (long)10, (long)1, (long)2, (long)9, (long)5, (long)7, (long)9}))) == (1));
    assert(candidate((std::vector<long>({(long)1, (long)9, (long)10, (long)1, (long)3}))) == (1));
    assert(candidate((std::vector<long>({(long)6, (long)9, (long)7, (long)5, (long)8, (long)7, (long)5, (long)3, (long)7, (long)5, (long)10, (long)10, (long)3, (long)6, (long)10, (long)2, (long)8, (long)6, (long)5, (long)4, (long)9, (long)5, (long)3, (long)10}))) == (5));
    assert(candidate((std::vector<long>({(long)1}))) == (1));
    assert(candidate((std::vector<long>({(long)8, (long)8, (long)10, (long)6, (long)4, (long)3, (long)5, (long)8, (long)2, (long)4, (long)2, (long)8, (long)4, (long)6, (long)10, (long)4, (long)2, (long)1, (long)10, (long)2, (long)1, (long)1, (long)5}))) == (4));
    assert(candidate((std::vector<long>({(long)2, (long)10, (long)4, (long)8, (long)2, (long)10, (long)5, (long)1, (long)2, (long)9, (long)5, (long)5, (long)6, (long)3, (long)8, (long)6, (long)4, (long)10}))) == (2));
    assert(candidate((std::vector<long>({(long)1, (long)6, (long)10, (long)1, (long)6, (long)9, (long)10, (long)8, (long)6, (long)8, (long)7, (long)3}))) == (1));
    assert(candidate((std::vector<long>({(long)9, (long)2, (long)4, (long)1, (long)5, (long)1, (long)5, (long)2, (long)5, (long)7, (long)7, (long)7, (long)3, (long)10, (long)1, (long)5, (long)4, (long)2, (long)8, (long)4, (long)1, (long)9, (long)10, (long)7, (long)10, (long)2, (long)8, (long)10, (long)9, (long)4}))) == (4));
    assert(candidate((std::vector<long>({(long)2, (long)6, (long)4, (long)2, (long)8, (long)7, (long)5, (long)6, (long)4, (long)10, (long)4, (long)6, (long)3, (long)7, (long)8, (long)8, (long)3, (long)1, (long)4, (long)2, (long)2, (long)10, (long)7}))) == (4));
    assert(candidate((std::vector<long>({(long)9, (long)8, (long)6, (long)10, (long)2, (long)6, (long)10, (long)2, (long)7, (long)8, (long)10, (long)3, (long)8, (long)2, (long)6, (long)2, (long)3, (long)1}))) == (2));
    assert(candidate((std::vector<long>({(long)5, (long)5, (long)3, (long)9, (long)5, (long)6, (long)3, (long)2, (long)8, (long)5, (long)6, (long)10, (long)10, (long)6, (long)8, (long)4, (long)10, (long)7, (long)7, (long)10, (long)8}))) == (-1));
    assert(candidate((std::vector<long>({(long)10}))) == (-1));
    assert(candidate((std::vector<long>({(long)9, (long)7, (long)7, (long)2, (long)4, (long)7, (long)2, (long)10, (long)9, (long)7, (long)5, (long)7, (long)2}))) == (2));
    assert(candidate((std::vector<long>({(long)5, (long)4, (long)10, (long)2, (long)1, (long)1, (long)10, (long)3, (long)6, (long)1, (long)8}))) == (1));
    assert(candidate((std::vector<long>({(long)7, (long)9, (long)9, (long)9, (long)3, (long)4, (long)1, (long)5, (long)9, (long)1, (long)2, (long)1, (long)1, (long)10, (long)7, (long)5, (long)6, (long)7, (long)6, (long)7, (long)7, (long)6}))) == (1));
    assert(candidate((std::vector<long>({(long)3, (long)10, (long)10, (long)9, (long)2}))) == (-1));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
// For each of the group, output the deepest level of nesting of parentheses.
// E.g. (()()) has maximum two levels of nesting while ((())) has three.
// >>> parse_nested_parens(("(()()) ((())) () ((())()())"))
// (std::vector<long>({(long)2, (long)3, (long)1, (long)3}))
std::vector<long> parse_nested_parens(std::string paren_string) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given vector of integers, return vector in strange order.
// Strange sorting, is when you start with the minimum value,
// then maximum of the remaining integers, then minimum and so on.
// Examples:
// >>> strange_sort_list((std::vector<long>({(long)1, (long)2, (long)3, (long)4})))
// (std::vector<long>({(long)1, (long)4, (long)2, (long)3}))
// >>> strange_sort_list((std::vector<long>({(long)5, (long)5, (long)5, (long)5})))
// (std::vector<long>({(long)5, (long)5, (long)5, (long)5}))
// >>> strange_sort_list((std::vector<long>()))
// (std::vector<long>())
std::vector<long> strange_sort_list(std::vector<long> lst) {

}
int main() {
    auto candidate = strange_sort_list;
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4}))) == (std::vector<long>({(long)1, (long)4, (long)2, (long)3})));
    assert(candidate((std::vector<long>({(long)5, (long)6, (long)7, (long)8, (long)9}))) == (std::vector<long>({(long)5, (long)9, (long)6, (long)8, (long)7})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5}))) == (std::vector<long>({(long)1, (long)5, (long)2, (long)4, (long)3})));
    assert(candidate((std::vector<long>({(long)5, (long)6, (long)7, (long)8, (long)9, (long)1}))) == (std::vector<long>({(long)1, (long)9, (long)5, (long)8, (long)6, (long)7})));
    assert(candidate((std::vector<long>({(long)5, (long)5, (long)5, (long)5}))) == (std::vector<long>({(long)5, (long)5, (long)5, (long)5})));
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6, (long)7, (long)8}))) == (std::vector<long>({(long)1, (long)8, (long)2, (long)7, (long)3, (long)6, (long)4, (long)5})));
    assert(candidate((std::vector<long>({(long)0, (long)2, (long)2, (long)2, (long)5, (long)5, (long)-5, (long)-5}))) == (std::vector<long>({(long)-5, (long)5, (long)-5, (long)5, (long)0, (long)2, (long)2, (long)2})));
    assert(candidate((std::vector<long>({(long)111111}))) == (std::vector<long>({(long)111111})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given the lengths of the three sides of a triangle. Return the area of
// the triangle rounded to 2 decimal points if the three sides form a valid triangle.
// Otherwise return -1
// Three sides make a valid triangle when the sum of any two sides is greater
// than the third side.
// Example:
// >>> triangle_area((3), (4), (5))
// (6.0f)
// >>> triangle_area((1), (2), (10))
// (float(-1))
float triangle_area(long a, long b, long c) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that returns true if the object q will fly, and false otherwise.
// The object q will fly if it's balanced (it is a palindromic vector) and the sum of its elements is less than or equal the maximum possible weight w.
// Example:
// >>> will_it_fly((std::vector<long>({(long)1, (long)2})), (5))
// (false)
// # 1+2 is less than the maximum possible weight, but it's unbalanced.
// >>> will_it_fly((std::vector<long>({(long)3, (long)2, (long)3})), (1))
// (false)
// # it's balanced, but 3+2+3 is more than the maximum possible weight.
// >>> will_it_fly((std::vector<long>({(long)3, (long)2, (long)3})), (9))
// (true)
// # 3+2+3 is less than the maximum possible weight, and it's balanced.
// >>> will_it_fly((std::vector<long>({(long)3})), (5))
// (true)
// # 3 is less than the maximum possible weight, and it's balanced.
bool will_it_fly(std::vector<long> q, long w) {

}
int main() {
    auto candidate = will_it_fly;
    assert(candidate((std::vector<long>({(long)3, (long)2, (long)3})), (9)) == (true));
    assert(candidate((std::vector<long>({(long)1, (long)2})), (5)) == (false));
    assert(candidate((std::vector<long>({(long)3})), (5)) == (true));
    assert(candidate((std::vector<long>({(long)3, (long)2, (long)3})), (1)) == (false));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3})), (6)) == (false));
    assert(candidate((std::vector<long>({(long)5})), (5)) == (true));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector arr of integers, find the minimum number of elements that
// need to be changed to make the vector palindromic. A palindromic vector is a vector that
// is read the same backwards and forwards. In one change, you can change one element to any other element.
// For example:
// >>> smallest_change((std::vector<long>({(long)1, (long)2, (long)3, (long)5, (long)4, (long)7, (long)9, (long)6})))
// (4)
// >>> smallest_change((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)3, (long)2, (long)2})))
// (1)
// >>> smallest_change((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)1})))
// (0)
long smallest_change(std::vector<long> arr) {

}
int main() {
    auto candidate = smallest_change;
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)5, (long)4, (long)7, (long)9, (long)6}))) == (4));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)3, (long)2, (long)2}))) == (1));
    assert(candidate((std::vector<long>({(long)1, (long)4, (long)2}))) == (1));
    assert(candidate((std::vector<long>({(long)1, (long)4, (long)4, (long)2}))) == (1));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)2, (long)1}))) == (0));
    assert(candidate((std::vector<long>({(long)3, (long)1, (long)1, (long)3}))) == (0));
    assert(candidate((std::vector<long>({(long)1}))) == (0));
    assert(candidate((std::vector<long>({(long)0, (long)1}))) == (1));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that accepts two vectors of strings and returns the vector that has
// total number of chars in the all strings of the vector less than the other vector.
// if the two vectors have the same number of chars, return the first vector.
// Examples
// >>> total_match((std::vector<std::string>()), (std::vector<std::string>()))
// (std::vector<std::string>())
// >>> total_match((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hI", (std::string)"Hi"})))
// (std::vector<std::string>({(std::string)"hI", (std::string)"Hi"}))
// >>> total_match((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hi", (std::string)"hi", (std::string)"admin", (std::string)"project"})))
// (std::vector<std::string>({(std::string)"hi", (std::string)"admin"}))
// >>> total_match((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hI", (std::string)"hi", (std::string)"hi"})))
// (std::vector<std::string>({(std::string)"hI", (std::string)"hi", (std::string)"hi"}))
// >>> total_match((std::vector<std::string>({(std::string)"4"})), (std::vector<std::string>({(std::string)"1", (std::string)"2", (std::string)"3", (std::string)"4", (std::string)"5"})))
// (std::vector<std::string>({(std::string)"4"}))
std::vector<std::string> total_match(std::vector<std::string> lst1, std::vector<std::string> lst2) {

}
int main() {
    auto candidate = total_match;
    assert(candidate((std::vector<std::string>()), (std::vector<std::string>())) == (std::vector<std::string>()));
    assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hi", (std::string)"hi"}))) == (std::vector<std::string>({(std::string)"hi", (std::string)"hi"})));
    assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hi", (std::string)"hi", (std::string)"admin", (std::string)"project"}))) == (std::vector<std::string>({(std::string)"hi", (std::string)"admin"})));
    assert(candidate((std::vector<std::string>({(std::string)"4"})), (std::vector<std::string>({(std::string)"1", (std::string)"2", (std::string)"3", (std::string)"4", (std::string)"5"}))) == (std::vector<std::string>({(std::string)"4"})));
    assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hI", (std::string)"Hi"}))) == (std::vector<std::string>({(std::string)"hI", (std::string)"Hi"})));
    assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hI", (std::string)"hi", (std::string)"hi"}))) == (std::vector<std::string>({(std::string)"hI", (std::string)"hi", (std::string)"hi"})));
    assert(candidate((std::vector<std::string>({(std::string)"hi", (std::string)"admin"})), (std::vector<std::string>({(std::string)"hI", (std::string)"hi", (std::string)"hii"}))) == (std::vector<std::string>({(std::string)"hi", (std::string)"admin"})));
    assert(candidate((std::vector<std::string>()), (std::vector<std::string>({(std::string)"this"}))) == (std::vector<std::string>()));
    assert(candidate((std::vector<std::string>({(std::string)"this"})), (std::vector<std::string>())) == (std::vector<std::string>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that returns true if the given number is the multiplication of 3 prime numbers
// and false otherwise.
// Knowing that (a) is less then 100.
// Example:
// >>> is_multiply_prime((30))
// (true)
// 30 = 2 * 3 * 5
bool is_multiply_prime(long a) {

}
int main() {
    auto candidate = is_multiply_prime;
    assert(candidate((5)) == (false));
    assert(candidate((30)) == (true));
    assert(candidate((8)) == (true));
    assert(candidate((10)) == (false));
    assert(candidate((125)) == (true));
    assert(candidate((105)) == (true));
    assert(candidate((126)) == (false));
    assert(candidate((729)) == (false));
    assert(candidate((891)) == (false));
    assert(candidate((1001)) == (true));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Your task is to write a function that returns true if a number x is a simple
// power of n and false in other cases.
// x is a simple power of n if n**int=x
// For example:
// >>> is_simple_power((1), (4))
// (true)
// >>> is_simple_power((2), (2))
// (true)
// >>> is_simple_power((8), (2))
// (true)
// >>> is_simple_power((3), (2))
// (false)
// >>> is_simple_power((3), (1))
// (false)
// >>> is_simple_power((5), (3))
// (false)
bool is_simple_power(long x, long n) {

}
int main() {
    auto candidate = is_simple_power;
    assert(candidate((16), (2)) == (true));
    assert(candidate((143214), (16)) == (false));
    assert(candidate((4), (2)) == (true));
    assert(candidate((9), (3)) == (true));
    assert(candidate((16), (4)) == (true));
    assert(candidate((24), (2)) == (false));
    assert(candidate((128), (4)) == (false));
    assert(candidate((12), (6)) == (false));
    assert(candidate((1), (1)) == (true));
    assert(candidate((1), (12)) == (true));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes an integer a and returns true
// if this ingeger is a cube of some integer number.
// Note: you may assume the input is always valid.
// Examples:
// >>> iscube((1))
// (true)
// >>> iscube((2))
// (false)
// >>> iscube((-1))
// (true)
// >>> iscube((64))
// (true)
// >>> iscube((0))
// (true)
// >>> iscube((180))
// (false)
bool iscube(long a) {

}
int main() {
    auto candidate = iscube;
    assert(candidate((1)) == (true));
    assert(candidate((2)) == (false));
    assert(candidate((-1)) == (true));
    assert(candidate((64)) == (true));
    assert(candidate((180)) == (false));
    assert(candidate((1000)) == (true));
    assert(candidate((0)) == (true));
    assert(candidate((1729)) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You have been tasked to write a function that receives
// a hexadecimal number as a string and counts the number of hexadecimal
// digits that are primes (prime number, or a prime, is a natural number
// greater than 1 that is not a product of two smaller natural numbers).
// Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
// Prime numbers are 2, 3, 5, 7, 11, 13, 17,...
// So you have to determine a number of the following digits: 2, 3, 5, 7,
// B (=decimal 11), D (=decimal 13).
// Note: you may assume the input is always correct or empty string,
// and symbols A,B,C,D,E,F are always uppercase.
// Examples:
// >>> hex_key(("AB"))
// (1)
// >>> hex_key(("1077E"))
// (2)
// >>> hex_key(("ABED1A33"))
// (4)
// >>> hex_key(("123456789ABCDEF0"))
// (6)
// >>> hex_key(("2020"))
// (2)
long hex_key(std::string num) {

}
int main() {
    auto candidate = hex_key;
    assert(candidate(("AB")) == (1));
    assert(candidate(("1077E")) == (2));
    assert(candidate(("ABED1A33")) == (4));
    assert(candidate(("2020")) == (2));
    assert(candidate(("123456789ABCDEF0")) == (6));
    assert(candidate(("112233445566778899AABBCCDDEEFF00")) == (12));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You will be given a number in decimal form and your task is to convert it to
// binary format. The function should return a string, with each character representing a binary
// number. Each character in the string will be '0' or '1'.
// There will be an extra couple of characters 'db' at the beginning and at the end of the string.
// The extra characters are there to help with the format.
// Examples:
// >>> decimal_to_binary((15))
// ("db1111db")
// >>> decimal_to_binary((32))
// ("db100000db")
std::string decimal_to_binary(long decimal) {

}
int main() {
    auto candidate = decimal_to_binary;
    assert(candidate((0)) == ("db0db"));
    assert(candidate((32)) == ("db100000db"));
    assert(candidate((103)) == ("db1100111db"));
    assert(candidate((15)) == ("db1111db"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Filter an input vector of strings only for ones that contain given substring
// >>> filter_by_substring((std::vector<std::string>()), ("a"))
// (std::vector<std::string>())
// >>> filter_by_substring((std::vector<std::string>({(std::string)"abc", (std::string)"bacd", (std::string)"cde", (std::string)"array"})), ("a"))
// (std::vector<std::string>({(std::string)"abc", (std::string)"bacd", (std::string)"array"}))
std::vector<std::string> filter_by_substring(std::vector<std::string> strings, std::string substring) {

}
int main() {
    auto candidate = filter_by_substring;
    assert(candidate((std::vector<std::string>()), ("john")) == (std::vector<std::string>()));
    assert(candidate((std::vector<std::string>({(std::string)"xxx", (std::string)"asd", (std::string)"xxy", (std::string)"john doe", (std::string)"xxxAAA", (std::string)"xxx"})), ("xxx")) == (std::vector<std::string>({(std::string)"xxx", (std::string)"xxxAAA", (std::string)"xxx"})));
    assert(candidate((std::vector<std::string>({(std::string)"xxx", (std::string)"asd", (std::string)"aaaxxy", (std::string)"john doe", (std::string)"xxxAAA", (std::string)"xxx"})), ("xx")) == (std::vector<std::string>({(std::string)"xxx", (std::string)"aaaxxy", (std::string)"xxxAAA", (std::string)"xxx"})));
    assert(candidate((std::vector<std::string>({(std::string)"grunt", (std::string)"trumpet", (std::string)"prune", (std::string)"gruesome"})), ("run")) == (std::vector<std::string>({(std::string)"grunt", (std::string)"prune"})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a string s.
// Your task is to check if the string is hapcpp or not.
// A string is hapcpp if its length is at least 3 and every 3 consecutive letters are distinct
// For example:
// >>> is_happy(("a"))
// (false)
// >>> is_happy(("aa"))
// (false)
// >>> is_happy(("abcd"))
// (true)
// >>> is_happy(("aabb"))
// (false)
// >>> is_happy(("adb"))
// (true)
// >>> is_happy(("xyy"))
// (false)
bool is_happy(std::string s) {

}
int main() {
    auto candidate = is_happy;
    assert(candidate(("a")) == (false));
    assert(candidate(("aa")) == (false));
    assert(candidate(("abcd")) == (true));
    assert(candidate(("aabb")) == (false));
    assert(candidate(("adb")) == (true));
    assert(candidate(("xyy")) == (false));
    assert(candidate(("iopaxpoi")) == (true));
    assert(candidate(("iopaxioi")) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// It is the last week of the semester and the teacher has to give the grades
// to students. The teacher has been making her own algorithm for grading.
// The only problem is, she has lost the code she used for grading.
// She has given you a vector of GPAs for some students and you have to write
// a function that can output a vector of letter grades using the following table:
// GPA       |    Letter grade
// 4.0                A+
// > 3.7                A
// > 3.3                A-
// > 3.0                B+
// > 2.7                B
// > 2.3                B-
// > 2.0                C+
// > 1.7                C
// > 1.3                C-
// > 1.0                D+
// > 0.7                D
// > 0.0                D-
// 0.0                E
// Example:
// >>> grade_equation((std::vector<float>({(float)4.0f, (float)3, (float)1.7f, (float)2, (float)3.5f})))
// (std::vector<std::string>({(std::string)"A+", (std::string)"B", (std::string)"C-", (std::string)"C", (std::string)"A-"}))
std::vector<std::string> numerical_letter_grade(std::vector<float> grades) {

}
int main() {
    auto candidate = numerical_letter_grade;
    assert(candidate((std::vector<float>({(float)4.0f, (float)3, (float)1.7f, (float)2, (float)3.5f}))) == (std::vector<std::string>({(std::string)"A+", (std::string)"B", (std::string)"C-", (std::string)"C", (std::string)"A-"})));
    assert(candidate((std::vector<float>({(float)1.2f}))) == (std::vector<std::string>({(std::string)"D+"})));
    assert(candidate((std::vector<float>({(float)0.5f}))) == (std::vector<std::string>({(std::string)"D-"})));
    assert(candidate((std::vector<float>({(float)0.0f}))) == (std::vector<std::string>({(std::string)"E"})));
    assert(candidate((std::vector<float>({(float)1.0f, (float)0.3f, (float)1.5f, (float)2.8f, (float)3.3f}))) == (std::vector<std::string>({(std::string)"D", (std::string)"D-", (std::string)"C-", (std::string)"B", (std::string)"B+"})));
    assert(candidate((std::vector<float>({(float)0.0f, (float)0.7f}))) == (std::vector<std::string>({(std::string)"E", (std::string)"D-"})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes a string and returns true if the string
// length is a prime number or false otherwise
// Examples
// >>> prime_length(("Hello"))
// (true)
// >>> prime_length(("abcdcba"))
// (true)
// >>> prime_length(("kittens"))
// (true)
// >>> prime_length(("orange"))
// (false)
bool prime_length(std::string string) {

}
int main() {
    auto candidate = prime_length;
    assert(candidate(("Hello")) == (true));
    assert(candidate(("abcdcba")) == (true));
    assert(candidate(("kittens")) == (true));
    assert(candidate(("orange")) == (false));
    assert(candidate(("wow")) == (true));
    assert(candidate(("world")) == (true));
    assert(candidate(("MadaM")) == (true));
    assert(candidate(("Wow")) == (true));
    assert(candidate(("")) == (false));
    assert(candidate(("HI")) == (true));
    assert(candidate(("go")) == (true));
    assert(candidate(("gogo")) == (false));
    assert(candidate(("aaaaaaaaaaaaaaa")) == (false));
    assert(candidate(("Madam")) == (true));
    assert(candidate(("M")) == (false));
    assert(candidate(("0")) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, return the count of the numbers of n-digit
// positive integers that start or end with 1.
long starts_one_ends(long n) {

}
int main() {
    auto candidate = starts_one_ends;
    assert(candidate((1)) == (1));
    assert(candidate((2)) == (18));
    assert(candidate((3)) == (180));
    assert(candidate((4)) == (1800));
    assert(candidate((5)) == (18000));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer N, return the total sum of its digits in binary.
// Example
// >>> solve((1000))
// ("1")
// >>> solve((150))
// ("110")
// >>> solve((147))
// ("1100")
// Variables:
// @N integer
// Constraints: 0 ≤ N ≤ 10000.
// Output:
// a string of binary number
std::string solve(long N) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a non-empty vector of integers lst. add the even elements that are at odd indices..
// Examples:
// >>> add((std::vector<long>({(long)4, (long)2, (long)6, (long)7})))
// (2)
long add(std::vector<long> lst) {

}
int main() {
    auto candidate = add;
    assert(candidate((std::vector<long>({(long)4, (long)88}))) == (88));
    assert(candidate((std::vector<long>({(long)4, (long)5, (long)6, (long)7, (long)2, (long)122}))) == (122));
    assert(candidate((std::vector<long>({(long)4, (long)0, (long)6, (long)7}))) == (0));
    assert(candidate((std::vector<long>({(long)4, (long)4, (long)6, (long)8}))) == (12));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes a string and returns an ordered version of it.
// Ordered version of string, is a string where all words (separated by space)
// are replaced by a new word where all the characters arranged in
// ascending order based on ascii value.
// Note: You should keep the order of words and blank spaces in the sentence.
// For example:
// >>> anti_shuffle(("Hi"))
// ("Hi")
// >>> anti_shuffle(("hello"))
// ("ehllo")
// >>> anti_shuffle(("Hello World!!!"))
// ("Hello !!!Wdlor")
std::string anti_shuffle(std::string s) {

}
int main() {
    auto candidate = anti_shuffle;
    assert(candidate(("Hi")) == ("Hi"));
    assert(candidate(("hello")) == ("ehllo"));
    assert(candidate(("number")) == ("bemnru"));
    assert(candidate(("abcd")) == ("abcd"));
    assert(candidate(("Hello World!!!")) == ("Hello !!!Wdlor"));
    assert(candidate(("")) == (""));
    assert(candidate(("Hi. My name is Mister Robot. How are you?")) == (".Hi My aemn is Meirst .Rboot How aer ?ouy"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a 2 dimensional data, as a nested vectors,
// which is similar to matrix, however, unlike matrices,
// each row may contain a different number of columns.
// Given lst, and integer x, find integers x in the vector,
// and return vector of tuples, [(x1, y1), (x2, y2) ...] such that
// each tuple is a coordinate - (row, columns), starting with 0.
// Sort coordinates initially by rows in ascending order.
// Also, sort coordinates of the row by columns in descending order.
// Examples:
// >>> get_row((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})})), (1))
// (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 0), (std::tuple<long, long>)std::make_tuple(1, 4), (std::tuple<long, long>)std::make_tuple(1, 0), (std::tuple<long, long>)std::make_tuple(2, 5), (std::tuple<long, long>)std::make_tuple(2, 0)}))
// >>> get_row((std::vector<std::vector<long>>()), (1))
// (std::vector<std::tuple<long, long>>())
// >>> get_row((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>(), (std::vector<long>)std::vector<long>({(long)1}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3})})), (3))
// (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(2, 2)}))
std::vector<std::tuple<long, long>> get_row(std::vector<std::vector<long>> lst, long x) {

}
int main() {
    auto candidate = get_row;
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})})), (1)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 0), (std::tuple<long, long>)std::make_tuple(1, 4), (std::tuple<long, long>)std::make_tuple(1, 0), (std::tuple<long, long>)std::make_tuple(2, 5), (std::tuple<long, long>)std::make_tuple(2, 0)})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6})})), (2)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 1), (std::tuple<long, long>)std::make_tuple(1, 1), (std::tuple<long, long>)std::make_tuple(2, 1), (std::tuple<long, long>)std::make_tuple(3, 1), (std::tuple<long, long>)std::make_tuple(4, 1), (std::tuple<long, long>)std::make_tuple(5, 1)})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)3, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)1, (long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)1, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)1})})), (1)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(0, 0), (std::tuple<long, long>)std::make_tuple(1, 0), (std::tuple<long, long>)std::make_tuple(2, 1), (std::tuple<long, long>)std::make_tuple(2, 0), (std::tuple<long, long>)std::make_tuple(3, 2), (std::tuple<long, long>)std::make_tuple(3, 0), (std::tuple<long, long>)std::make_tuple(4, 3), (std::tuple<long, long>)std::make_tuple(4, 0), (std::tuple<long, long>)std::make_tuple(5, 4), (std::tuple<long, long>)std::make_tuple(5, 0), (std::tuple<long, long>)std::make_tuple(6, 5), (std::tuple<long, long>)std::make_tuple(6, 0)})));
    assert(candidate((std::vector<std::vector<long>>()), (1)) == (std::vector<std::tuple<long, long>>()));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1})})), (2)) == (std::vector<std::tuple<long, long>>()));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>(), (std::vector<long>)std::vector<long>({(long)1}), (std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3})})), (3)) == (std::vector<std::tuple<long, long>>({(std::tuple<long, long>)std::make_tuple(2, 2)})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector of non-negative integers, return a cocpp of the given vector after sorting,
// you will sort the given vector in ascending order if the sum( first index value, last index value) is odd,
// or sort it in descending order if the sum( first index value, last index value) is even.
// Note:
// * don't change the given vector.
// Examples:
// >>> sort_array((std::vector<long>()))
// (std::vector<long>())
// >>> sort_array((std::vector<long>({(long)5})))
// (std::vector<long>({(long)5}))
// >>> sort_array((std::vector<long>({(long)2, (long)4, (long)3, (long)0, (long)1, (long)5})))
// (std::vector<long>({(long)0, (long)1, (long)2, (long)3, (long)4, (long)5}))
// >>> sort_array((std::vector<long>({(long)2, (long)4, (long)3, (long)0, (long)1, (long)5, (long)6})))
// (std::vector<long>({(long)6, (long)5, (long)4, (long)3, (long)2, (long)1, (long)0}))
std::vector<long> sort_array(std::vector<long> array) {

}
int main() {
    auto candidate = sort_array;
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)5}))) == (std::vector<long>({(long)5})));
    assert(candidate((std::vector<long>({(long)2, (long)4, (long)3, (long)0, (long)1, (long)5}))) == (std::vector<long>({(long)0, (long)1, (long)2, (long)3, (long)4, (long)5})));
    assert(candidate((std::vector<long>({(long)2, (long)4, (long)3, (long)0, (long)1, (long)5, (long)6}))) == (std::vector<long>({(long)6, (long)5, (long)4, (long)3, (long)2, (long)1, (long)0})));
    assert(candidate((std::vector<long>({(long)2, (long)1}))) == (std::vector<long>({(long)1, (long)2})));
    assert(candidate((std::vector<long>({(long)15, (long)42, (long)87, (long)32, (long)11, (long)0}))) == (std::vector<long>({(long)0, (long)11, (long)15, (long)32, (long)42, (long)87})));
    assert(candidate((std::vector<long>({(long)21, (long)14, (long)23, (long)11}))) == (std::vector<long>({(long)23, (long)21, (long)14, (long)11})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Create a function encrypt that takes a string as an argument and
// returns a string encrypted with the alphabet being rotated.
// The alphabet should be rotated in a manner such that the letters
// shift down by two multiplied to two places.
// For example:
// >>> encrypt(("hi"))
// ("lm")
// >>> encrypt(("asdfghjkl"))
// ("ewhjklnop")
// >>> encrypt(("gf"))
// ("kj")
// >>> encrypt(("et"))
// ("ix")
std::string encrypt(std::string s) {

}
int main() {
    auto candidate = encrypt;
    assert(candidate(("hi")) == ("lm"));
    assert(candidate(("asdfghjkl")) == ("ewhjklnop"));
    assert(candidate(("gf")) == ("kj"));
    assert(candidate(("et")) == ("ix"));
    assert(candidate(("faewfawefaewg")) == ("jeiajeaijeiak"));
    assert(candidate(("hellomyfriend")) == ("lippsqcjvmirh"));
    assert(candidate(("dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh")) == ("hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl"));
    assert(candidate(("a")) == ("e"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// For a given vector of integers, return a tuple consisting of a sum and a product of all the integers in a vector.
// Empty sum should be equal to 0 and empty product should be equal to 1.
// >>> sum_product((std::vector<long>()))
// (std::make_tuple(0, 1))
// >>> sum_product((std::vector<long>({(long)1, (long)2, (long)3, (long)4})))
// (std::make_tuple(10, 24))
std::tuple<long, long> sum_product(std::vector<long> numbers) {

}
int main() {
    auto candidate = sum_product;
    assert(candidate((std::vector<long>())) == (std::make_tuple(0, 1)));
    assert(candidate((std::vector<long>({(long)1, (long)1, (long)1}))) == (std::make_tuple(3, 1)));
    assert(candidate((std::vector<long>({(long)100, (long)0}))) == (std::make_tuple(100, 0)));
    assert(candidate((std::vector<long>({(long)3, (long)5, (long)7}))) == (std::make_tuple(15, 105)));
    assert(candidate((std::vector<long>({(long)10}))) == (std::make_tuple(10, 10)));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a vector of integers.
// Write a function next_smallest() that returns the 2nd smallest element of the vector.
// Return None if there is no such element.
// >>> next_smallest((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5})))
// 2
// >>> next_smallest((std::vector<long>({(long)5, (long)1, (long)4, (long)3, (long)2})))
// 2
// >>> next_smallest((std::vector<long>()))
// std::nullopt
// >>> next_smallest((std::vector<long>({(long)1, (long)1})))
// std::nullopt
std::optional<long> next_smallest(std::vector<long> lst) {

}
int main() {
    auto candidate = next_smallest;
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5}))) == 2);
    assert(candidate((std::vector<long>({(long)5, (long)1, (long)4, (long)3, (long)2}))) == 2);
    assert(candidate((std::vector<long>())) == std::nullopt);
    assert(candidate((std::vector<long>({(long)1, (long)1}))) == std::nullopt);
    assert(candidate((std::vector<long>({(long)1, (long)1, (long)1, (long)1, (long)0}))) == 1);
    assert(candidate((std::vector<long>({(long)1, (long)1}))) == std::nullopt);
    assert(candidate((std::vector<long>({(long)-35, (long)34, (long)12, (long)-45}))) == -35);
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You'll be given a string of words, and your task is to count the number
// of boredoms. A boredom is a sentence that starts with the word "I".
// Sentences are delimited by '.', '?' or '!'.
// For example:
// >>> is_bored(("Hello world"))
// (0)
// >>> is_bored(("The sky is blue. The sun is shining. I love this weather"))
// (1)
long is_bored(std::string S) {

}
int main() {
    auto candidate = is_bored;
    assert(candidate(("Hello world")) == (0));
    assert(candidate(("Is the sky blue?")) == (0));
    assert(candidate(("I love It !")) == (1));
    assert(candidate(("bIt")) == (0));
    assert(candidate(("I feel good today. I will be productive. will kill It")) == (2));
    assert(candidate(("You and I are going for a walk")) == (0));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Create a function that takes 3 numbers.
// Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
// Returns false in any other cases.
// Examples
// >>> any_int((float(5)), (float(2)), (float(7)))
// (true)
// >>> any_int((float(3)), (float(2)), (float(2)))
// (false)
// >>> any_int((float(3)), (float(-2)), (float(1)))
// (true)
// >>> any_int((3.6f), (-2.2f), (float(2)))
// (false)
bool any_int(float x, float y, float z) {

}
int main() {
    auto candidate = any_int;
    assert(candidate((float(2)), (float(3)), (float(1))) == (true));
    assert(candidate((2.5f), (float(2)), (float(3))) == (false));
    assert(candidate((1.5f), (float(5)), (3.5f)) == (false));
    assert(candidate((float(2)), (float(6)), (float(2))) == (false));
    assert(candidate((float(4)), (float(2)), (float(2))) == (true));
    assert(candidate((2.2f), (2.2f), (2.2f)) == (false));
    assert(candidate((float(-4)), (float(6)), (float(2))) == (true));
    assert(candidate((float(2)), (float(1)), (float(1))) == (true));
    assert(candidate((float(3)), (float(4)), (float(7))) == (true));
    assert(candidate((3.0f), (float(4)), (float(7))) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Write a function that takes a message, and encodes in such a
// way that it swaps case of all letters, replaces all vowels in
// the message with the letter that appears 2 places ahead of that
// vowel in the english alphabet.
// Assume only letters.
// Examples:
// >>> encode(("test"))
// ("TGST")
// >>> encode(("This is a message"))
// ("tHKS KS C MGSSCGG")
std::string encode(std::string message) {

}
int main() {
    auto candidate = encode;
    assert(candidate(("TEST")) == ("tgst"));
    assert(candidate(("Mudasir")) == ("mWDCSKR"));
    assert(candidate(("YES")) == ("ygs"));
    assert(candidate(("This is a message")) == ("tHKS KS C MGSSCGG"));
    assert(candidate(("I DoNt KnOw WhAt tO WrItE")) == ("k dQnT kNqW wHcT Tq wRkTg"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a vector of integers.
// You need to find the largest prime value and return the sum of its digits.
// Examples:
// >>> skjkasdkd((std::vector<long>({(long)0, (long)3, (long)2, (long)1, (long)3, (long)5, (long)7, (long)4, (long)5, (long)5, (long)5, (long)2, (long)181, (long)32, (long)4, (long)32, (long)3, (long)2, (long)32, (long)324, (long)4, (long)3})))
// (10)
// >>> skjkasdkd((std::vector<long>({(long)1, (long)0, (long)1, (long)8, (long)2, (long)4597, (long)2, (long)1, (long)3, (long)40, (long)1, (long)2, (long)1, (long)2, (long)4, (long)2, (long)5, (long)1})))
// (25)
// >>> skjkasdkd((std::vector<long>({(long)1, (long)3, (long)1, (long)32, (long)5107, (long)34, (long)83278, (long)109, (long)163, (long)23, (long)2323, (long)32, (long)30, (long)1, (long)9, (long)3})))
// (13)
// >>> skjkasdkd((std::vector<long>({(long)0, (long)724, (long)32, (long)71, (long)99, (long)32, (long)6, (long)0, (long)5, (long)91, (long)83, (long)0, (long)5, (long)6})))
// (11)
// >>> skjkasdkd((std::vector<long>({(long)0, (long)81, (long)12, (long)3, (long)1, (long)21})))
// (3)
// >>> skjkasdkd((std::vector<long>({(long)0, (long)8, (long)1, (long)2, (long)1, (long)7})))
// (7)
long skjkasdkd(std::vector<long> lst) {

}
int main() {
    auto candidate = skjkasdkd;
    assert(candidate((std::vector<long>({(long)0, (long)3, (long)2, (long)1, (long)3, (long)5, (long)7, (long)4, (long)5, (long)5, (long)5, (long)2, (long)181, (long)32, (long)4, (long)32, (long)3, (long)2, (long)32, (long)324, (long)4, (long)3}))) == (10));
    assert(candidate((std::vector<long>({(long)1, (long)0, (long)1, (long)8, (long)2, (long)4597, (long)2, (long)1, (long)3, (long)40, (long)1, (long)2, (long)1, (long)2, (long)4, (long)2, (long)5, (long)1}))) == (25));
    assert(candidate((std::vector<long>({(long)1, (long)3, (long)1, (long)32, (long)5107, (long)34, (long)83278, (long)109, (long)163, (long)23, (long)2323, (long)32, (long)30, (long)1, (long)9, (long)3}))) == (13));
    assert(candidate((std::vector<long>({(long)0, (long)724, (long)32, (long)71, (long)99, (long)32, (long)6, (long)0, (long)5, (long)91, (long)83, (long)0, (long)5, (long)6}))) == (11));
    assert(candidate((std::vector<long>({(long)0, (long)81, (long)12, (long)3, (long)1, (long)21}))) == (3));
    assert(candidate((std::vector<long>({(long)0, (long)8, (long)1, (long)2, (long)1, (long)7}))) == (7));
    assert(candidate((std::vector<long>({(long)8191}))) == (19));
    assert(candidate((std::vector<long>({(long)8191, (long)123456, (long)127, (long)7}))) == (19));
    assert(candidate((std::vector<long>({(long)127, (long)97, (long)8192}))) == (10));
}