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>
// 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>
// Given a map, return true if all keys are strings in lower
// case or all keys are strings in upper case, else return false.
// The function should return false is the given map is empty.
// Examples:
// >>> check_dict_case((std::map<std::string,std::string>({{"a", "apple"}, {"b", "banana"}})))
// (true)
// >>> check_dict_case((std::map<std::string,std::string>({{"a", "apple"}, {"A", "banana"}, {"B", "banana"}})))
// (false)
// >>> check_dict_case((std::map<std::string,std::string>({{"a", "apple"}, {8, "banana"}, {"a", "apple"}})))
// (false)
// >>> check_dict_case((std::map<std::string,std::string>({{"Name", "John"}, {"Age", "36"}, {"City", "Houston"}})))
// (false)
// >>> check_dict_case((std::map<std::string,std::string>({{"STATE", "NC"}, {"ZIP", "12345"}})))
// (true)
bool check_dict_case(std::map<std::string,std::string> dict) {

}
int main() {
    auto candidate = check_dict_case;
    assert(candidate((std::map<std::string,std::string>({{"p", "pineapple"}, {"b", "banana"}}))) == (true));
    assert(candidate((std::map<std::string,std::string>({{"p", "pineapple"}, {"A", "banana"}, {"B", "banana"}}))) == (false));
    assert(candidate((std::map<std::string,std::string>({{"p", "pineapple"}, {"5", "banana"}, {"a", "apple"}}))) == (false));
    assert(candidate((std::map<std::string,std::string>({{"Name", "John"}, {"Age", "36"}, {"City", "Houston"}}))) == (false));
    assert(candidate((std::map<std::string,std::string>({{"STATE", "NC"}, {"ZIP", "12345"}}))) == (true));
    assert(candidate((std::map<std::string,std::string>({{"fruit", "Orange"}, {"taste", "Sweet"}}))) == (true));
    assert(candidate((std::map<std::string,std::string>())) == (false));
}


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>
// Given a string text, replace all spaces in it with underscores,
// and if a string has more than 2 consecutive spaces,
// then replace all consecutive spaces with -
// >>> fix_spaces((" Example"))
// ("Example")
// >>> fix_spaces((" Example 1"))
// ("Example_1")
// >>> fix_spaces((" Example 2"))
// ("_Example_2")
// >>> fix_spaces((" Example 3"))
// ("_Example-3")
std::string fix_spaces(std::string text) {

}
int main() {
    auto candidate = fix_spaces;
    assert(candidate(("Example")) == ("Example"));
    assert(candidate(("Mudasir Hanif ")) == ("Mudasir_Hanif_"));
    assert(candidate(("Yellow Yellow  Dirty  Fellow")) == ("Yellow_Yellow__Dirty__Fellow"));
    assert(candidate(("Exa   mple")) == ("Exa-mple"));
    assert(candidate(("   Exa 1 2 2 mple")) == ("-Exa_1_2_2_mple"));
}


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>
// Given a vector of numbers, return the sum of squares of the numbers
// in the vector that are odd. Ignore numbers that are negative or not integers.
// >>> double_the_difference((std::vector<float>({(long)1, (long)3, (long)2, (long)0})))
// (10)
// >>> double_the_difference((std::vector<float>({(long)-1, (long)-2, (long)0})))
// (0)
// >>> double_the_difference((std::vector<float>({(long)9, (long)-2})))
// (81)
// >>> double_the_difference((std::vector<float>({(long)0})))
// (0)
// If the input vector is empty, return 0.
long double_the_difference(std::vector<float> lst) {

}
int main() {
    auto candidate = double_the_difference;
    assert(candidate((std::vector<float>())) == (0));
    assert(candidate((std::vector<float>({(float)5.0f, (float)4.0f}))) == (25));
    assert(candidate((std::vector<float>({(float)0.1f, (float)0.2f, (float)0.3f}))) == (0));
    assert(candidate((std::vector<float>({(float)-10.0f, (float)-20.0f, (float)-30.0f}))) == (0));
    assert(candidate((std::vector<float>({(float)-1.0f, (float)-2.0f, (float)8.0f}))) == (0));
    assert(candidate((std::vector<float>({(float)0.2f, (float)3.0f, (float)5.0f}))) == (34));
    assert(candidate((std::vector<float>({(float)-9.0f, (float)-7.0f, (float)-5.0f, (float)-3.0f, (float)-1.0f, (float)1.0f, (float)3.0f, (float)5.0f, (float)7.0f, (float)9.0f}))) == (165));
}


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>
// 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>
// 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>
// 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>
// Return vector of all prefixes from shortest to longest of the input string
// >>> all_prefixes(("abc"))
// (std::vector<std::string>({(std::string)"a", (std::string)"ab", (std::string)"abc"}))
std::vector<std::string> all_prefixes(std::string string) {

}
int main() {
    auto candidate = all_prefixes;
    assert(candidate(("")) == (std::vector<std::string>()));
    assert(candidate(("asdfgh")) == (std::vector<std::string>({(std::string)"a", (std::string)"as", (std::string)"asd", (std::string)"asdf", (std::string)"asdfg", (std::string)"asdfgh"})));
    assert(candidate(("WWW")) == (std::vector<std::string>({(std::string)"W", (std::string)"WW", (std::string)"WWW"})));
}


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>
// 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>
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it,
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// >>> max_fill((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)1, (long)0}), (std::vector<long>)std::vector<long>({(long)0, (long)1, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1})})), (1))
// (6)
// Example 2:
// >>> max_fill((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)1, (long)1, (long)1, (long)1}), (std::vector<long>)std::vector<long>({(long)0, (long)1, (long)1, (long)1})})), (2))
// (5)
// Example 3:
// >>> max_fill((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0}), (std::vector<long>)std::vector<long>({(long)0, (long)0, (long)0})})), (5))
// (0)
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
long max_fill(std::vector<std::vector<long>> grid, long capacity) {

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


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>
// 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>
// Given a vector of integers, sort the integers that are between 1 and 9 inclusive,
// reverse the resulting vector, and then replace each digit by its corresponding name from
// "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".
// For example:
// >>> by_length((std::vector<long>({(long)2, (long)1, (long)1, (long)4, (long)5, (long)8, (long)2, (long)3})))
// (std::vector<std::string>({(std::string)"Eight", (std::string)"Five", (std::string)"Four", (std::string)"Three", (std::string)"Two", (std::string)"Two", (std::string)"One", (std::string)"One"}))
// If the vector is empty, return an empty vector:
// >>> by_length((std::vector<long>()))
// (std::vector<std::string>())
// If the vector has any strange number ignore it:
// >>> by_length((std::vector<long>({(long)1, (long)-1, (long)55})))
// (std::vector<std::string>({(std::string)"One"}))
std::vector<std::string> by_length(std::vector<long> arr) {

}
int main() {
    auto candidate = by_length;
    assert(candidate((std::vector<long>({(long)2, (long)1, (long)1, (long)4, (long)5, (long)8, (long)2, (long)3}))) == (std::vector<std::string>({(std::string)"Eight", (std::string)"Five", (std::string)"Four", (std::string)"Three", (std::string)"Two", (std::string)"Two", (std::string)"One", (std::string)"One"})));
    assert(candidate((std::vector<long>())) == (std::vector<std::string>()));
    assert(candidate((std::vector<long>({(long)1, (long)-1, (long)55}))) == (std::vector<std::string>({(std::string)"One"})));
    assert(candidate((std::vector<long>({(long)1, (long)-1, (long)3, (long)2}))) == (std::vector<std::string>({(std::string)"Three", (std::string)"Two", (std::string)"One"})));
    assert(candidate((std::vector<long>({(long)9, (long)4, (long)8}))) == (std::vector<std::string>({(std::string)"Nine", (std::string)"Eight", (std::string)"Four"})));
}


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>
// Implement a function that takes an non-negative integer and returns a vector of the first n
// integers that are prime numbers and less than n.
// for example:
// >>> count_up_to((5))
// (std::vector<long>({(long)2, (long)3}))
// >>> count_up_to((11))
// (std::vector<long>({(long)2, (long)3, (long)5, (long)7}))
// >>> count_up_to((0))
// (std::vector<long>())
// >>> count_up_to((20))
// (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17, (long)19}))
// >>> count_up_to((1))
// (std::vector<long>())
// >>> count_up_to((18))
// (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17}))
std::vector<long> count_up_to(long n) {

}
int main() {
    auto candidate = count_up_to;
    assert(candidate((5)) == (std::vector<long>({(long)2, (long)3})));
    assert(candidate((6)) == (std::vector<long>({(long)2, (long)3, (long)5})));
    assert(candidate((7)) == (std::vector<long>({(long)2, (long)3, (long)5})));
    assert(candidate((10)) == (std::vector<long>({(long)2, (long)3, (long)5, (long)7})));
    assert(candidate((0)) == (std::vector<long>()));
    assert(candidate((22)) == (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17, (long)19})));
    assert(candidate((1)) == (std::vector<long>()));
    assert(candidate((18)) == (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17})));
    assert(candidate((47)) == (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17, (long)19, (long)23, (long)29, (long)31, (long)37, (long)41, (long)43})));
    assert(candidate((101)) == (std::vector<long>({(long)2, (long)3, (long)5, (long)7, (long)11, (long)13, (long)17, (long)19, (long)23, (long)29, (long)31, (long)37, (long)41, (long)43, (long)47, (long)53, (long)59, (long)61, (long)67, (long)71, (long)73, (long)79, (long)83, (long)89, (long)97})));
}


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>
// 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>
// 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>
// Create a function that takes a string as input which contains only square brackets.
// The function should return true if and only if there is a valid subsequence of brackets
// where at least one bracket in the subsequence is nested.
// >>> is_nested(("[[]]"))
// (true)
// >>> is_nested(("[]]]]]]][[[[[]"))
// (false)
// >>> is_nested(("[][]"))
// (false)
// >>> is_nested(("[]"))
// (false)
// >>> is_nested(("[[][]]"))
// (true)
// >>> is_nested(("[[]][["))
// (true)
bool is_nested(std::string string) {

}
int main() {
    auto candidate = is_nested;
    assert(candidate(("[[]]")) == (true));
    assert(candidate(("[]]]]]]][[[[[]")) == (false));
    assert(candidate(("[][]")) == (false));
    assert(candidate(("[]")) == (false));
    assert(candidate(("[[[[]]]]")) == (true));
    assert(candidate(("[]]]]]]]]]]")) == (false));
    assert(candidate(("[][][[]]")) == (true));
    assert(candidate(("[[]")) == (false));
    assert(candidate(("[]]")) == (false));
    assert(candidate(("[[]][[")) == (true));
    assert(candidate(("[[][]]")) == (true));
    assert(candidate(("")) == (false));
    assert(candidate(("[[[[[[[[")) == (false));
    assert(candidate(("]]]]]]]]")) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
union Union_std_string_long{
    std::string f0;
    long f1;    Union_std_string_long(std::string _f0) : f0(_f0) {}
    Union_std_string_long(long _f1) : f1(_f1) {}
    ~Union_std_string_long() {}
    bool operator==(std::string f) {
        return f0 == f ;
    }    bool operator==(long f) {
        return f1 == f ;
    }
};
// You are given two positive integers n and m, and your task is to compute the
// average of the integers from n through m (including n and m).
// Round the answer to the nearest integer and convert that to binary.
// If n is greater than m, return -1.
// Example:
// >>> rounded_avg((1), (5))
// "0b11"
// >>> rounded_avg((7), (5))
// -1
// >>> rounded_avg((10), (20))
// "0b1111"
// >>> rounded_avg((20), (33))
// "0b11010"
Union_std_string_long rounded_avg(long n, long m) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector of strings, where each string consists of only digits, return a vector.
// Each element i of the output should be "the number of odd elements in the
// string i of the input." where all the i's should be replaced by the number
// of odd digits in the i'th string of the input.
// >>> odd_count((std::vector<std::string>({(std::string)"1234567"})))
// (std::vector<std::string>({(std::string)"the number of odd elements 4n the str4ng 4 of the 4nput."}))
// >>> odd_count((std::vector<std::string>({(std::string)"3", (std::string)"11111111"})))
// (std::vector<std::string>({(std::string)"the number of odd elements 1n the str1ng 1 of the 1nput.", (std::string)"the number of odd elements 8n the str8ng 8 of the 8nput."}))
std::vector<std::string> odd_count(std::vector<std::string> lst) {

}
int main() {
    auto candidate = odd_count;
    assert(candidate((std::vector<std::string>({(std::string)"1234567"}))) == (std::vector<std::string>({(std::string)"the number of odd elements 4n the str4ng 4 of the 4nput."})));
    assert(candidate((std::vector<std::string>({(std::string)"3", (std::string)"11111111"}))) == (std::vector<std::string>({(std::string)"the number of odd elements 1n the str1ng 1 of the 1nput.", (std::string)"the number of odd elements 8n the str8ng 8 of the 8nput."})));
    assert(candidate((std::vector<std::string>({(std::string)"271", (std::string)"137", (std::string)"314"}))) == (std::vector<std::string>({(std::string)"the number of odd elements 2n the str2ng 2 of the 2nput.", (std::string)"the number of odd elements 3n the str3ng 3 of the 3nput.", (std::string)"the number of odd elements 2n the str2ng 2 of the 2nput."})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// We have a vector 'arr' of N integers arr[1], arr[2], ..., arr[N].The
// numbers in the vector will be randomly ordered. Your task is to determine if
// it is possible to get a vector sorted in non-decreasing order by performing
// the following operation on the given vector:
// You are allowed to perform right shift operation any number of times.
// One right shift operation means shifting all elements of the vector by one
// position in the right direction. The last element of the vector will be moved to
// the starting position in the vector i.e. 0th index.
// If it is possible to obtain the sorted vector by performing the above operation
// then return true else return false.
// If the given vector is empty then return true.
// Note: The given vector is guaranteed to have unique elements.
// For Example:
// >>> move_one_ball((std::vector<long>({(long)3, (long)4, (long)5, (long)1, (long)2})))
// (true)
// Explanation: By performin 2 right shift operations, non-decreasing order can
// be achieved for the given vector.
// >>> move_one_ball((std::vector<long>({(long)3, (long)5, (long)4, (long)1, (long)2})))
// (false)
// Explanation:It is not possible to get non-decreasing order for the given
// vector by performing any number of right shift operations.
bool move_one_ball(std::vector<long> arr) {

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


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, return a tuple that has the number of even and odd
// integer palindromes that fall within the range(1, n), inclusive.
// Example 1:
// >>> even_odd_palindrome((3))
// (std::make_tuple(1, 2))
// Explanation:
// Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.
// Example 2:
// >>> even_odd_palindrome((12))
// (std::make_tuple(4, 6))
// Explanation:
// Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.
// Note:
// 1. 1 <= n <= 10^3
// 2. returned tuple has the number of even and odd integer palindromes respectively.
std::tuple<long, long> even_odd_palindrome(long n) {

}
int main() {
    auto candidate = even_odd_palindrome;
    assert(candidate((123)) == (std::make_tuple(8, 13)));
    assert(candidate((12)) == (std::make_tuple(4, 6)));
    assert(candidate((3)) == (std::make_tuple(1, 2)));
    assert(candidate((63)) == (std::make_tuple(6, 8)));
    assert(candidate((25)) == (std::make_tuple(5, 6)));
    assert(candidate((19)) == (std::make_tuple(4, 6)));
    assert(candidate((9)) == (std::make_tuple(4, 5)));
    assert(candidate((1)) == (std::make_tuple(0, 1)));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Evaluate whether the given number n can be written as the sum of exactly 4 positive even numbers
// Example
// >>> is_equal_to_sum_even((4))
// (false)
// >>> is_equal_to_sum_even((6))
// (false)
// >>> is_equal_to_sum_even((8))
// (true)
bool is_equal_to_sum_even(long n) {

}
int main() {
    auto candidate = is_equal_to_sum_even;
    assert(candidate((4)) == (false));
    assert(candidate((6)) == (false));
    assert(candidate((8)) == (true));
    assert(candidate((10)) == (true));
    assert(candidate((11)) == (false));
    assert(candidate((12)) == (true));
    assert(candidate((13)) == (false));
    assert(candidate((16)) == (true));
}


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>
// Given a vector of numbers, return whether or not they are sorted
// in ascending order. If vector has more than 1 duplicate of the same
// number, return false. Assume no negative numbers and only integers.
// Examples
// >>> is_sorted((std::vector<long>({(long)5})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5})))
// (false)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6, (long)7})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)3, (long)2, (long)4, (long)5, (long)6, (long)7})))
// (false)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)2, (long)3, (long)3, (long)4})))
// (true)
// >>> is_sorted((std::vector<long>({(long)1, (long)2, (long)2, (long)2, (long)3, (long)4})))
// (false)
bool is_sorted(std::vector<long> lst) {

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


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>
// Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in
// the last couple centuries. However, what people don't know is Tribonacci sequence.
// Tribonacci sequence is defined by the recurrence:
// tri(1) = 3
// tri(n) = 1 + n / 2, if n is even.
// tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
// For example:
// tri(2) = 1 + (2 / 2) = 2
// tri(4) = 3
// tri(3) = tri(2) + tri(1) + tri(4)
// = 2 + 3 + 3 = 8
// You are given a non-negative integer number n, you have to a return a vector of the
// first n + 1 numbers of the Tribonacci sequence.
// Examples:
// >>> tri((3))
// (std::vector<long>({(long)1, (long)3, (long)2, (long)8}))
std::vector<long> tri(long n) {

}
int main() {
    auto candidate = tri;
    assert(candidate((3)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8})));
    assert(candidate((4)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3})));
    assert(candidate((5)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15})));
    assert(candidate((6)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4})));
    assert(candidate((7)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24})));
    assert(candidate((8)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24, (long)5})));
    assert(candidate((9)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24, (long)5, (long)35})));
    assert(candidate((20)) == (std::vector<long>({(long)1, (long)3, (long)2, (long)8, (long)3, (long)15, (long)4, (long)24, (long)5, (long)35, (long)6, (long)48, (long)7, (long)63, (long)8, (long)80, (long)9, (long)99, (long)10, (long)120, (long)11})));
    assert(candidate((0)) == (std::vector<long>({(long)1})));
    assert(candidate((1)) == (std::vector<long>({(long)1, (long)3})));
}


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>
// 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 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 grid with N rows and N columns (N >= 2) and a positive integer k,
// each cell of the grid contains a value. Every integer in the range [1, N * N]
// inclusive appears exactly once on the cells of the grid.
// You have to find the minimum path of length k in the grid. You can start
// from any cell, and in each step you can move to any of the neighbor cells,
// in other words, you can go to cells which share an edge with you current
// cell.
// Please note that a path of length k means visiting exactly k cells (not
// necessarily distinct).
// You CANNOT go off the grid.
// A path A (of length k) is considered less than a path B (of length k) if
// after making the ordered vectors of the values on the cells that A and B go
// through (let's call them lst_A and lst_B), lst_A is lexicographically less
// than lst_B, in other words, there exist an integer index i (1 <= i <= k)
// such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have
// lst_A[j] = lst_B[j].
// It is guaranteed that the answer is unique.
// Return an ordered vector of the values on the cells that the minimum path go through.
// Examples:
// >>> minPath((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)9})})), (3))
// (std::vector<long>({(long)1, (long)2, (long)1}))
// >>> minPath((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)5, (long)9, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)2})})), (1))
// (std::vector<long>({(long)1}))
std::vector<long> minPath(std::vector<std::vector<long>> grid, long k) {

}
int main() {
    auto candidate = minPath;
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)5, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)9})})), (3)) == (std::vector<long>({(long)1, (long)2, (long)1})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)5, (long)9, (long)3}), (std::vector<long>)std::vector<long>({(long)4, (long)1, (long)6}), (std::vector<long>)std::vector<long>({(long)7, (long)8, (long)2})})), (1)) == (std::vector<long>({(long)1})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2, (long)3, (long)4}), (std::vector<long>)std::vector<long>({(long)5, (long)6, (long)7, (long)8}), (std::vector<long>)std::vector<long>({(long)9, (long)10, (long)11, (long)12}), (std::vector<long>)std::vector<long>({(long)13, (long)14, (long)15, (long)16})})), (4)) == (std::vector<long>({(long)1, (long)2, (long)1, (long)2})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)6, (long)4, (long)13, (long)10}), (std::vector<long>)std::vector<long>({(long)5, (long)7, (long)12, (long)1}), (std::vector<long>)std::vector<long>({(long)3, (long)16, (long)11, (long)15}), (std::vector<long>)std::vector<long>({(long)8, (long)14, (long)9, (long)2})})), (7)) == (std::vector<long>({(long)1, (long)10, (long)1, (long)10, (long)1, (long)10, (long)1})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)8, (long)14, (long)9, (long)2}), (std::vector<long>)std::vector<long>({(long)6, (long)4, (long)13, (long)15}), (std::vector<long>)std::vector<long>({(long)5, (long)7, (long)1, (long)12}), (std::vector<long>)std::vector<long>({(long)3, (long)10, (long)11, (long)16})})), (5)) == (std::vector<long>({(long)1, (long)7, (long)1, (long)7, (long)1})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)11, (long)8, (long)7, (long)2}), (std::vector<long>)std::vector<long>({(long)5, (long)16, (long)14, (long)4}), (std::vector<long>)std::vector<long>({(long)9, (long)3, (long)15, (long)6}), (std::vector<long>)std::vector<long>({(long)12, (long)13, (long)10, (long)1})})), (9)) == (std::vector<long>({(long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)12, (long)13, (long)10, (long)1}), (std::vector<long>)std::vector<long>({(long)9, (long)3, (long)15, (long)6}), (std::vector<long>)std::vector<long>({(long)5, (long)16, (long)14, (long)4}), (std::vector<long>)std::vector<long>({(long)11, (long)8, (long)7, (long)2})})), (12)) == (std::vector<long>({(long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6, (long)1, (long)6})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)2, (long)7, (long)4}), (std::vector<long>)std::vector<long>({(long)3, (long)1, (long)5}), (std::vector<long>)std::vector<long>({(long)6, (long)8, (long)9})})), (8)) == (std::vector<long>({(long)1, (long)3, (long)1, (long)3, (long)1, (long)3, (long)1, (long)3})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)6, (long)1, (long)5}), (std::vector<long>)std::vector<long>({(long)3, (long)8, (long)9}), (std::vector<long>)std::vector<long>({(long)2, (long)7, (long)4})})), (8)) == (std::vector<long>({(long)1, (long)5, (long)1, (long)5, (long)1, (long)5, (long)1, (long)5})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)2}), (std::vector<long>)std::vector<long>({(long)3, (long)4})})), (10)) == (std::vector<long>({(long)1, (long)2, (long)1, (long)2, (long)1, (long)2, (long)1, (long)2, (long)1, (long)2})));
    assert(candidate((std::vector<std::vector<long>>({(std::vector<long>)std::vector<long>({(long)1, (long)3}), (std::vector<long>)std::vector<long>({(long)3, (long)2})})), (10)) == (std::vector<long>({(long)1, (long)3, (long)1, (long)3, (long)1, (long)3, (long)1, (long)3, (long)1, (long)3})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a string s, count the number of uppercase vowels in even indices.
// For example:
// >>> count_upper(("aBCdEf"))
// (1)
// >>> count_upper(("abcdefg"))
// (0)
// >>> count_upper(("dBBE"))
// (0)
long count_upper(std::string s) {

}
int main() {
    auto candidate = count_upper;
    assert(candidate(("aBCdEf")) == (1));
    assert(candidate(("abcdefg")) == (0));
    assert(candidate(("dBBE")) == (0));
    assert(candidate(("B")) == (0));
    assert(candidate(("U")) == (1));
    assert(candidate(("")) == (0));
    assert(candidate(("EEEE")) == (2));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a vector arr of integers and a positive integer k, return a sorted vector
// of length k with the maximum k numbers in arr.
// Example 1:
// >>> maximum((std::vector<long>({(long)-3, (long)-4, (long)5})), (3))
// (std::vector<long>({(long)-4, (long)-3, (long)5}))
// Example 2:
// >>> maximum((std::vector<long>({(long)4, (long)-4, (long)4})), (2))
// (std::vector<long>({(long)4, (long)4}))
// Example 3:
// >>> maximum((std::vector<long>({(long)-3, (long)2, (long)1, (long)2, (long)-1, (long)-2, (long)1})), (1))
// (std::vector<long>({(long)2}))
// Note:
// 1. The length of the vector will be in the range of [1, 1000].
// 2. The elements in the vector will be in the range of [-1000, 1000].
// 3. 0 <= k <= len(arr)
std::vector<long> maximum(std::vector<long> arr, long k) {

}
int main() {
    auto candidate = maximum;
    assert(candidate((std::vector<long>({(long)-3, (long)-4, (long)5})), (3)) == (std::vector<long>({(long)-4, (long)-3, (long)5})));
    assert(candidate((std::vector<long>({(long)4, (long)-4, (long)4})), (2)) == (std::vector<long>({(long)4, (long)4})));
    assert(candidate((std::vector<long>({(long)-3, (long)2, (long)1, (long)2, (long)-1, (long)-2, (long)1})), (1)) == (std::vector<long>({(long)2})));
    assert(candidate((std::vector<long>({(long)123, (long)-123, (long)20, (long)0, (long)1, (long)2, (long)-3})), (3)) == (std::vector<long>({(long)2, (long)20, (long)123})));
    assert(candidate((std::vector<long>({(long)-123, (long)20, (long)0, (long)1, (long)2, (long)-3})), (4)) == (std::vector<long>({(long)0, (long)1, (long)2, (long)20})));
    assert(candidate((std::vector<long>({(long)5, (long)15, (long)0, (long)3, (long)-13, (long)-8, (long)0})), (7)) == (std::vector<long>({(long)-13, (long)-8, (long)0, (long)0, (long)3, (long)5, (long)15})));
    assert(candidate((std::vector<long>({(long)-1, (long)0, (long)2, (long)5, (long)3, (long)-10})), (2)) == (std::vector<long>({(long)3, (long)5})));
    assert(candidate((std::vector<long>({(long)1, (long)0, (long)5, (long)-7})), (1)) == (std::vector<long>({(long)5})));
    assert(candidate((std::vector<long>({(long)4, (long)-4})), (2)) == (std::vector<long>({(long)-4, (long)4})));
    assert(candidate((std::vector<long>({(long)-10, (long)10})), (2)) == (std::vector<long>({(long)-10, (long)10})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)-23, (long)243, (long)-400, (long)0})), (0)) == (std::vector<long>()));
}


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>
// 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>
// Implement the function f that takes n as a parameter,
// and returns a vector of size n, such that the value of the element at index i is the factorial of i if i is even
// or the sum of numbers from 1 to i otherwise.
// i starts from 1.
// the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).
// Example:
// >>> f((5))
// (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15}))
std::vector<long> f(long n) {

}
int main() {
    auto candidate = f;
    assert(candidate((5)) == (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15})));
    assert(candidate((7)) == (std::vector<long>({(long)1, (long)2, (long)6, (long)24, (long)15, (long)720, (long)28})));
    assert(candidate((1)) == (std::vector<long>({(long)1})));
    assert(candidate((3)) == (std::vector<long>({(long)1, (long)2, (long)6})));
}


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>
// 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'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>
// 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>
// 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>
// There are eight planets in our solar system: the closerst to the Sun
// is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn,
// Uranus, Neptune.
// Write a function that takes two planet names as strings planet1 and planet2.
// The function should return a tuple containing all planets whose orbits are
// located between the orbit of planet1 and the orbit of planet2, sorted by
// the proximity to the sun.
// The function should return an empty tuple if planet1 or planet2
// are not correct planet names.
// Examples
// >>> bf(("Jupiter"), ("Neptune"))
// (std::vector<std::string>({(std::string)"Saturn", (std::string)"Uranus"}))
// >>> bf(("Earth"), ("Mercury"))
// (std::vector<std::string>("Venus"))
// >>> bf(("Mercury"), ("Uranus"))
// (std::vector<std::string>({(std::string)"Venus", (std::string)"Earth", (std::string)"Mars", (std::string)"Jupiter", (std::string)"Saturn"}))
std::vector<std::string> bf(std::string planet1, std::string planet2) {

}
int main() {
    auto candidate = bf;
    assert(candidate(("Jupiter"), ("Neptune")) == (std::vector<std::string>({(std::string)"Saturn", (std::string)"Uranus"})));
    assert(candidate(("Earth"), ("Mercury")) == (std::vector<std::string>({(std::string)"Venus"})));
    assert(candidate(("Mercury"), ("Uranus")) == (std::vector<std::string>({(std::string)"Venus", (std::string)"Earth", (std::string)"Mars", (std::string)"Jupiter", (std::string)"Saturn"})));
    assert(candidate(("Neptune"), ("Venus")) == (std::vector<std::string>({(std::string)"Earth", (std::string)"Mars", (std::string)"Jupiter", (std::string)"Saturn", (std::string)"Uranus"})));
    assert(candidate(("Earth"), ("Earth")) == (std::vector<std::string>()));
    assert(candidate(("Mars"), ("Earth")) == (std::vector<std::string>()));
    assert(candidate(("Jupiter"), ("Makemake")) == (std::vector<std::string>()));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a positive integer n, return the product of the odd digits.
// Return 0 if all digits are even.
// For example:
// >>> digits((1))
// (1)
// >>> digits((4))
// (0)
// >>> digits((235))
// (15)
long digits(long n) {

}
int main() {
    auto candidate = digits;
    assert(candidate((5)) == (5));
    assert(candidate((54)) == (5));
    assert(candidate((120)) == (1));
    assert(candidate((5014)) == (5));
    assert(candidate((98765)) == (315));
    assert(candidate((5576543)) == (2625));
    assert(candidate((2468)) == (0));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You will be given a string of words separated by commas or spaces. Your task is
// to split the string into words and return a vector of the words.
// For example:
// >>> words_string(("Hi, my name is John"))
// (std::vector<std::string>({(std::string)"Hi", (std::string)"my", (std::string)"name", (std::string)"is", (std::string)"John"}))
// >>> words_string(("One, two, three, four, five, six"))
// (std::vector<std::string>({(std::string)"One", (std::string)"two", (std::string)"three", (std::string)"four", (std::string)"five", (std::string)"six"}))
std::vector<std::string> words_string(std::string s) {

}
int main() {
    auto candidate = words_string;
    assert(candidate(("Hi, my name is John")) == (std::vector<std::string>({(std::string)"Hi", (std::string)"my", (std::string)"name", (std::string)"is", (std::string)"John"})));
    assert(candidate(("One, two, three, four, five, six")) == (std::vector<std::string>({(std::string)"One", (std::string)"two", (std::string)"three", (std::string)"four", (std::string)"five", (std::string)"six"})));
    assert(candidate(("Hi, my name")) == (std::vector<std::string>({(std::string)"Hi", (std::string)"my", (std::string)"name"})));
    assert(candidate(("One,, two, three, four, five, six,")) == (std::vector<std::string>({(std::string)"One", (std::string)"two", (std::string)"three", (std::string)"four", (std::string)"five", (std::string)"six"})));
    assert(candidate(("")) == (std::vector<std::string>()));
    assert(candidate(("ahmed     , gamal")) == (std::vector<std::string>({(std::string)"ahmed", (std::string)"gamal"})));
}


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>
union Union_long_float_std_string{
    long f0;
    float f1;
    std::string f2;    Union_long_float_std_string(long _f0) : f0(_f0) {}
    Union_long_float_std_string(float _f1) : f1(_f1) {}
    Union_long_float_std_string(std::string _f2) : f2(_f2) {}
    ~Union_long_float_std_string() {}
    bool operator==(long f) {
        return f0 == f ;
    }    bool operator==(float f) {
        return f1 == f ;
    }    bool operator==(std::string f) {
        return f2 == f ;
    }
};
union Union_long_float_std_string_std_nullopt{
    long f0;
    float f1;
    std::string f2;
    std::nullopt f3;    Union_long_float_std_string_std_nullopt(long _f0) : f0(_f0) {}
    Union_long_float_std_string_std_nullopt(float _f1) : f1(_f1) {}
    Union_long_float_std_string_std_nullopt(std::string _f2) : f2(_f2) {}
    Union_long_float_std_string_std_nullopt(std::nullopt _f3) : f3(_f3) {}
    ~Union_long_float_std_string_std_nullopt() {}
    bool operator==(long f) {
        return f0 == f ;
    }    bool operator==(float f) {
        return f1 == f ;
    }    bool operator==(std::string f) {
        return f2 == f ;
    }    bool operator==(std::nullopt f) {
        return f3 == f ;
    }
};
// Create a function that takes integers, floats, or strings representing
// real numbers, and returns the larger variable in its given variable type.
// Return None if the values are equal.
// Note: If a real number is represented as a string, the floating point might be . or ,
// >>> compare_one(1, 2.5f)
// 2.5f
// >>> compare_one(1, "2,3")
// "2,3"
// >>> compare_one("5,1", "6")
// "6"
// >>> compare_one("1", 1)
// std::nullopt
Union_long_float_std_string_std_nullopt compare_one(Union_long_float_std_string a, Union_long_float_std_string b) {

}
int main() {
    auto candidate = compare_one;
    assert(candidate(1, 2) == 2);
    assert(candidate(1, 2.5f) == 2.5f);
    assert(candidate(2, 3) == 3);
    assert(candidate(5, 6) == 6);
    assert(candidate(1, "2,3") == "2,3");
    assert(candidate("5,1", "6") == "6");
    assert(candidate("1", "2") == "2");
    assert(candidate("1", 1) == std::nullopt);
}


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>
// 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>
// 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>
// 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>
// 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>
// Write a function which sorts the given vector of integers
// in ascending order according to the sum of their digits.
// Note: if there are several items with similar sum of their digits,
// order them based on their index in original vector.
// For example:
// >>> order_by_points((std::vector<long>({(long)1, (long)11, (long)-1, (long)-11, (long)-12})))
// (std::vector<long>({(long)-1, (long)-11, (long)1, (long)-12, (long)11}))
// >>> order_by_points((std::vector<long>()))
// (std::vector<long>())
std::vector<long> order_by_points(std::vector<long> nums) {

}
int main() {
    auto candidate = order_by_points;
    assert(candidate((std::vector<long>({(long)1, (long)11, (long)-1, (long)-11, (long)-12}))) == (std::vector<long>({(long)-1, (long)-11, (long)1, (long)-12, (long)11})));
    assert(candidate((std::vector<long>({(long)1234, (long)423, (long)463, (long)145, (long)2, (long)423, (long)423, (long)53, (long)6, (long)37, (long)3457, (long)3, (long)56, (long)0, (long)46}))) == (std::vector<long>({(long)0, (long)2, (long)3, (long)6, (long)53, (long)423, (long)423, (long)423, (long)1234, (long)145, (long)37, (long)46, (long)56, (long)463, (long)3457})));
    assert(candidate((std::vector<long>())) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)1, (long)-11, (long)-32, (long)43, (long)54, (long)-98, (long)2, (long)-3}))) == (std::vector<long>({(long)-3, (long)-32, (long)-98, (long)-11, (long)1, (long)2, (long)43, (long)54})));
    assert(candidate((std::vector<long>({(long)1, (long)2, (long)3, (long)4, (long)5, (long)6, (long)7, (long)8, (long)9, (long)10, (long)11}))) == (std::vector<long>({(long)1, (long)10, (long)2, (long)11, (long)3, (long)4, (long)5, (long)6, (long)7, (long)8, (long)9})));
    assert(candidate((std::vector<long>({(long)0, (long)6, (long)6, (long)-76, (long)-21, (long)23, (long)4}))) == (std::vector<long>({(long)-76, (long)-21, (long)0, (long)4, (long)23, (long)6, (long)6})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Check if in given vector of numbers, are any two numbers closer to each other than
// given threshold.
// >>> has_close_elements((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f})), (0.5f))
// (false)
// >>> has_close_elements((std::vector<float>({(float)1.0f, (float)2.8f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})), (0.3f))
// (true)
bool has_close_elements(std::vector<float> numbers, float threshold) {

}
int main() {
    auto candidate = has_close_elements;
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.3f)) == (true));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.9f, (float)4.0f, (float)5.0f, (float)2.2f})), (0.05f)) == (false));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f})), (0.95f)) == (true));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)5.9f, (float)4.0f, (float)5.0f})), (0.8f)) == (false));
    assert(candidate((std::vector<float>({(float)1.0f, (float)2.0f, (float)3.0f, (float)4.0f, (float)5.0f, (float)2.0f})), (0.1f)) == (true));
    assert(candidate((std::vector<float>({(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f})), (1.0f)) == (true));
    assert(candidate((std::vector<float>({(float)1.1f, (float)2.2f, (float)3.1f, (float)4.1f, (float)5.1f})), (0.5f)) == (false));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Find the shortest palindrome that begins with a supplied string.
// Algorithm idea is simple:
// - Find the longest postfix of supplied string that is a palindrome.
// - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.
// >>> make_palindrome((""))
// ("")
// >>> make_palindrome(("cat"))
// ("catac")
// >>> make_palindrome(("cata"))
// ("catac")
std::string make_palindrome(std::string string) {

}
int main() {
    auto candidate = make_palindrome;
    assert(candidate(("")) == (""));
    assert(candidate(("x")) == ("x"));
    assert(candidate(("xyz")) == ("xyzyx"));
    assert(candidate(("xyx")) == ("xyx"));
    assert(candidate(("jerry")) == ("jerryrrej"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Input are two strings a and b consisting only of 1s and 0s.
// Perform binary XOR on these inputs and return result also as a string.
// >>> string_xor(("010"), ("110"))
// ("100")
std::string string_xor(std::string a, std::string b) {


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// The Brazilian factorial is defined as:
// brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
// where n > 0
// For example:
// >>> special_factorial((4))
// (288)
// The function will receive an integer as input and should return the special
// factorial of this integer.
long special_factorial(long n) {

}
int main() {
    auto candidate = special_factorial;
    assert(candidate((4)) == (288));
    assert(candidate((5)) == (34560));
    assert(candidate((7)) == (125411328000));
    assert(candidate((1)) == (1));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a non-empty vector of integers arr and an integer k, return
// the sum of the elements with at most two digits from the first k elements of arr.
// Example:
// >>> add_elements((std::vector<long>({(long)111, (long)21, (long)3, (long)4000, (long)5, (long)6, (long)7, (long)8, (long)9})), (4))
// (24)
// Constraints:
// 1. 1 <= len(arr) <= 100
// 2. 1 <= k <= len(arr)
long add_elements(std::vector<long> arr, long k) {

}
int main() {
    auto candidate = add_elements;
    assert(candidate((std::vector<long>({(long)1, (long)-2, (long)-3, (long)41, (long)57, (long)76, (long)87, (long)88, (long)99})), (3)) == (-4));
    assert(candidate((std::vector<long>({(long)111, (long)121, (long)3, (long)4000, (long)5, (long)6})), (2)) == (0));
    assert(candidate((std::vector<long>({(long)11, (long)21, (long)3, (long)90, (long)5, (long)6, (long)7, (long)8, (long)9})), (4)) == (125));
    assert(candidate((std::vector<long>({(long)111, (long)21, (long)3, (long)4000, (long)5, (long)6, (long)7, (long)8, (long)9})), (4)) == (24));
    assert(candidate((std::vector<long>({(long)1})), (1)) == (1));
}


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>
// Given a vector of positive integers x. return a sorted vector of all
// elements that hasn't any even digit.
// Note: Returned vector should be sorted in increasing order.
// For example:
// >>> unique_digits((std::vector<long>({(long)15, (long)33, (long)1422, (long)1})))
// (std::vector<long>({(long)1, (long)15, (long)33}))
// >>> unique_digits((std::vector<long>({(long)152, (long)323, (long)1422, (long)10})))
// (std::vector<long>())
std::vector<long> unique_digits(std::vector<long> x) {

}
int main() {
    auto candidate = unique_digits;
    assert(candidate((std::vector<long>({(long)15, (long)33, (long)1422, (long)1}))) == (std::vector<long>({(long)1, (long)15, (long)33})));
    assert(candidate((std::vector<long>({(long)152, (long)323, (long)1422, (long)10}))) == (std::vector<long>()));
    assert(candidate((std::vector<long>({(long)12345, (long)2033, (long)111, (long)151}))) == (std::vector<long>({(long)111, (long)151})));
    assert(candidate((std::vector<long>({(long)135, (long)103, (long)31}))) == (std::vector<long>({(long)31, (long)135})));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// Given a string s and a natural number n, you have been tasked to implement
// a function that returns a vector of all words from string s that contain exactly
// n consonants, in order these words appear in the string s.
// If the string s is empty then the function should return an empty vector.
// Note: you may assume the input string contains only letters and spaces.
// Examples:
// >>> select_words(("Mary had a little lamb"), (4))
// (std::vector<std::string>({(std::string)"little"}))
// >>> select_words(("Mary had a little lamb"), (3))
// (std::vector<std::string>({(std::string)"Mary", (std::string)"lamb"}))
// >>> select_words(("simple white space"), (2))
// (std::vector<std::string>())
// >>> select_words(("Hello world"), (4))
// (std::vector<std::string>({(std::string)"world"}))
// >>> select_words(("Uncle sam"), (3))
// (std::vector<std::string>({(std::string)"Uncle"}))
std::vector<std::string> select_words(std::string s, long n) {

}
int main() {
    auto candidate = select_words;
    assert(candidate(("Mary had a little lamb"), (4)) == (std::vector<std::string>({(std::string)"little"})));
    assert(candidate(("Mary had a little lamb"), (3)) == (std::vector<std::string>({(std::string)"Mary", (std::string)"lamb"})));
    assert(candidate(("simple white space"), (2)) == (std::vector<std::string>()));
    assert(candidate(("Hello world"), (4)) == (std::vector<std::string>({(std::string)"world"})));
    assert(candidate(("Uncle sam"), (3)) == (std::vector<std::string>({(std::string)"Uncle"})));
    assert(candidate((""), (4)) == (std::vector<std::string>()));
    assert(candidate(("a b c d e f"), (1)) == (std::vector<std::string>({(std::string)"b", (std::string)"c", (std::string)"d", (std::string)"f"})));
}


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>
// 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>
// You will be given the name of a class (a string) and a vector of extensions.
// The extensions are to be used to load additional classes to the class. The
// strength of the extension is as follows: Let CAP be the number of the uppercase
// letters in the extension's name, and let SM be the number of lowercase letters
// in the extension's name, the strength is given by the fraction CAP - SM.
// You should find the strongest extension and return a string in this
// format: ClassName.StrongestExtensionName.
// If there are two or more extensions with the same strength, you should
// choose the one that comes first in the vector.
// For example, if you are given "Slices" as the class and a vector of the
// extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should
// return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension
// (its strength is -1).
// Example:
// >>> Strongest_Extension(("my_class"), (std::vector<std::string>({(std::string)"AA", (std::string)"Be", (std::string)"CC"})))
// ("my_class.AA")
std::string Strongest_Extension(std::string class_name, std::vector<std::string> extensions) {

}
int main() {
    auto candidate = Strongest_Extension;
    assert(candidate(("Watashi"), (std::vector<std::string>({(std::string)"tEN", (std::string)"niNE", (std::string)"eIGHt8OKe"}))) == ("Watashi.eIGHt8OKe"));
    assert(candidate(("Boku123"), (std::vector<std::string>({(std::string)"nani", (std::string)"NazeDa", (std::string)"YEs.WeCaNe", (std::string)"32145tggg"}))) == ("Boku123.YEs.WeCaNe"));
    assert(candidate(("__YESIMHERE"), (std::vector<std::string>({(std::string)"t", (std::string)"eMptY", (std::string)"nothing", (std::string)"zeR00", (std::string)"NuLl__", (std::string)"123NoooneB321"}))) == ("__YESIMHERE.NuLl__"));
    assert(candidate(("K"), (std::vector<std::string>({(std::string)"Ta", (std::string)"TAR", (std::string)"t234An", (std::string)"cosSo"}))) == ("K.TAR"));
    assert(candidate(("__HAHA"), (std::vector<std::string>({(std::string)"Tab", (std::string)"123", (std::string)"781345", (std::string)"-_-"}))) == ("__HAHA.123"));
    assert(candidate(("YameRore"), (std::vector<std::string>({(std::string)"HhAas", (std::string)"okIWILL123", (std::string)"WorkOut", (std::string)"Fails", (std::string)"-_-"}))) == ("YameRore.okIWILL123"));
    assert(candidate(("finNNalLLly"), (std::vector<std::string>({(std::string)"Die", (std::string)"NowW", (std::string)"Wow", (std::string)"WoW"}))) == ("finNNalLLly.WoW"));
    assert(candidate(("_"), (std::vector<std::string>({(std::string)"Bb", (std::string)"91245"}))) == ("_.Bb"));
    assert(candidate(("Sp"), (std::vector<std::string>({(std::string)"671235", (std::string)"Bb"}))) == ("Sp.671235"));
}


Prompt:
#include<assert.h>
#include<bits/stdc++.h>
// You are given a vector of two strings, both strings consist of open
// parentheses '(' or close parentheses ')' only.
// Your job is to check if it is possible to concatenate the two strings in
// some order, that the resulting string will be good.
// A string S is considered to be good if and only if all parentheses in S
// are balanced. For example: the string '(())()' is good, while the string
// '())' is not.
// Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.
// Examples:
// >>> match_parens((std::vector<std::string>({(std::string)"()(", (std::string)")"})))
// ("Yes")
// >>> match_parens((std::vector<std::string>({(std::string)")", (std::string)")"})))
// ("No")
std::string match_parens(std::vector<std::string> lst) {

}
int main() {
    auto candidate = match_parens;
    assert(candidate((std::vector<std::string>({(std::string)"()(", (std::string)")"}))) == ("Yes"));
    assert(candidate((std::vector<std::string>({(std::string)")", (std::string)")"}))) == ("No"));
    assert(candidate((std::vector<std::string>({(std::string)"(()(())", (std::string)"())())"}))) == ("No"));
    assert(candidate((std::vector<std::string>({(std::string)")())", (std::string)"(()()("}))) == ("Yes"));
    assert(candidate((std::vector<std::string>({(std::string)"(())))", (std::string)"(()())(("}))) == ("Yes"));
    assert(candidate((std::vector<std::string>({(std::string)"()", (std::string)"())"}))) == ("No"));
    assert(candidate((std::vector<std::string>({(std::string)"(()(", (std::string)"()))()"}))) == ("Yes"));
    assert(candidate((std::vector<std::string>({(std::string)"((((", (std::string)"((())"}))) == ("No"));
    assert(candidate((std::vector<std::string>({(std::string)")(()", (std::string)"(()("}))) == ("No"));
    assert(candidate((std::vector<std::string>({(std::string)")(", (std::string)")("}))) == ("No"));
    assert(candidate((std::vector<std::string>({(std::string)"(", (std::string)")"}))) == ("Yes"));
    assert(candidate((std::vector<std::string>({(std::string)")", (std::string)"("}))) == ("Yes"));
}


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>
// 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>
// 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 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>
// A simple program which should return the value of x if n is
// a prime number and should return the value of y otherwise.
// Examples:
// >>> x_or_y((7), (34), (12))
// (34)
// >>> x_or_y((15), (8), (5))
// (5)
long x_or_y(long n, long x, long y) {


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>
// Given an integer. return a tuple that has the number of even and odd digits respectively.
// Example:
// >>> even_odd_count((-12))
// (std::make_tuple(1, 1))
// >>> even_odd_count((123))
// (std::make_tuple(1, 2))
std::tuple<long, long> even_odd_count(long num) {

}
int main() {
    auto candidate = even_odd_count;
    assert(candidate((7)) == (std::make_tuple(0, 1)));
    assert(candidate((-78)) == (std::make_tuple(1, 1)));
    assert(candidate((3452)) == (std::make_tuple(2, 2)));
    assert(candidate((346211)) == (std::make_tuple(3, 3)));
    assert(candidate((-345821)) == (std::make_tuple(3, 3)));
    assert(candidate((-2)) == (std::make_tuple(1, 0)));
    assert(candidate((-45347)) == (std::make_tuple(2, 3)));
    assert(candidate((0)) == (std::make_tuple(1, 0)));
}


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>
// 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>
// 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));
}