CS 61A

max(a*a+b*b,b*b+c*c,a*a+c*c)

factor = n - 1
while factor < n:
	if n % factor == 0:
		return factor
	factor -= 1

if cond():
	return true_func()
else:
	return false_func()

>>> 1 and 3 and 10 and 15
>>> 15

def falling(n, k):
    """Compute the falling factorial of n to depth k."""
    total, stop = 1, n-k
    while n > stop:
        total, n = total*n, n-1
    return total

def search(f):
    x = 0
    # 注意这里loop语法简洁
    
    while not f(x):
        x += 1
    return x

def inverse(f):
	return lambda y:search(lambda x:f(x)==y)

def search(f, y):
    x = 0
    # 注意这里loop语法简洁
    
    while not f(x) == y:
        x += 1
    return x

def inverse(f):
    def SetY(y):
        return search(f, y)
    return SetY

def inverse(f):
    def SetY(y):
        # 因为只有在这个frame里才需要用到x，所以选择在另一个函数内部定义SetX，其实是和匿名函数一个道理
        
        def SetX(x):
            return f(x) == y
        return search(SetX)
    return SetY

# 一个平方查找函数

def is_square_of_4(n):
    return square(4) == n
# 一个平方根查找函数

def is_sqrt_of_16(x):
    return square(x) == 16
# 利用search函数寻找x：

ans = search(is_sqrt_of_16)
# 扩充使用案例到16->n：

def sqrt(n):
	def is_sqrt_of_n(x):
    	return square(x) == n
    return search(is_sqrt_of_n)
# 扩充平方根函数，设计inverse,从内向外，逐层添加：

def inverse(f):
    def is_inverse_of_f(y):
        def is_inverse_of_y(x):
            return f(x) == y
    	return search(is_inverse_of_y)
    return is_inverse_of_f

# e.g.

sqrt = inverse(square)
Ans = sqrt(256)

def make_test_dice(*outcomes):
    """Return a die that cycles deterministically through OUTCOMES.

    >>> dice = make_test_dice(1, 2, 3)
    >>> dice()
    1
    >>> dice()
    2
    >>> dice()
    3
    >>> dice()
    1
    >>> dice()
    2

    This function uses Python syntax/techniques not yet covered in this course.
    The best way to understand it is by reading the documentation and examples.
    """
    assert len(outcomes) > 0, 'You must supply outcomes to make_test_dice'
    for o in outcomes:
        assert type(o) == int and o >= 1, 'Outcome is not a positive integer'
    index = len(outcomes) - 1

    def dice():
        nonlocal index
        index = (index + 1) % len(outcomes)
        return outcomes[index]

    return dice

def roll_dice(num_rolls, dice=six_sided):
    """Simulate rolling the DICE exactly NUM_ROLLS > 0 times. Return the sum of
    the outcomes unless any of the outcomes is 1. In that case, return 1.

    num_rolls:  The number of dice rolls that will be made.
    dice:       A function that simulates a single dice roll outcome.
    """
    # These assert statements ensure that num_rolls is a positive integer.
    
    assert type(num_rolls) == int, 'num_rolls must be an integer.'
    assert num_rolls > 0, 'Must roll at least once.'
    i, sum = 0, 0
    flag_1 = False
    while i < num_rolls:
        res = dice()
        if res == 1:
            flag_1 = True
        else:
            sum += res
        i += 1
    if flag_1:
        sum = 1
    return sum

def say_scores(score0, score1):
    """A commentary function that announces the score for each player."""
    
    print("Player 0 now has", score0, "and Player 1 now has", score1)
    return say_scores

def announce_lead_changes(last_leader=None):
    """Return a commentary function that announces lead changes."""

    >>> f0 = announce_lead_changes()
    >>> f1 = f0(5, 0)
    Player 0 takes the lead by 5
    >>> f2 = f1(5, 12)
    Player 1 takes the lead by 7
    >>> f3 = f2(8, 12)
    >>> f4 = f3(8, 13)
    >>> f5 = f4(15, 13)
    Player 0 takes the lead by 2

    def say(score0, score1):
        if score0 > score1:
            leader = 0
        elif score1 > score0:
            leader = 1
        else:
            leader = None
        if leader != None and leader != last_leader:
            print('Player', leader, 'takes the lead by', abs(score0 - score1))
        return announce_lead_changes(leader)

    return say

def both(f, g):
    """Return a commentary function that says what f says, then what g says."""

    NOTE: the following game is not possible under the rules, it's just
    an example for the sake of the doctest

    >>> h0 = both(say_scores, announce_lead_changes())
    >>> h1 = h0(10, 0)
    Player 0 now has 10 and Player 1 now has 0
    Player 0 takes the lead by 10
    >>> h2 = h1(10, 8)
    Player 0 now has 10 and Player 1 now has 8
    >>> h3 = h2(10, 17)
    Player 0 now has 10 and Player 1 now has 17
    Player 1 takes the lead by 7
    
    def say(score0, score1):
        return both(f(score0, score1), g(score0, score1))
    return say

y = "y"
h = y

def y(y):
    h = "h"
    if y == h:
        return y + "i"
    y = lambda y: y(h)
    return lambda h: y(h)

y = y(y)(y)

def sum_digits(n):
	if n < 10:
        return n
    else:
        all_but_last, last = n // 10, n % 10
        return sum_digits(all_but_last) + last

def luhn_sum(n):
    if n < 10:
        return n
    else:
        all_but_last, last = n // 10, n % 10
        return luhn_sum_double(all_but_last) + last
    
def luhn_sum_double(n):
    all_but_last, last = n // 10, n % 10
    last = sum_digits(2*last)
    if n < 10:
        return last
    else:
        return luhn_sum(all_but_last)+last

def luhn_sum(n, i=1):
    if n < 10:
        return sum_digits(2*n) if i % 2 == 1 else n
    else:
        all_but_last, last = n // 10, n % 10
        if i % 2 == 1:
            i += 1
            return luhn_sum(all_but_last, i) + last
        else:
            i += 1
            last = sum_digits(2*last)
            return luhn_sum(all_but_last, i) + last

a = []
for i in range(100):
    a.append(0)

def list_r_from_n(n,r):
    for i in range(n,r-1,-1):
        # 保存遍历过的数字
        
        a[r]=i
        # base case:
        
        if r == 1:
            for j in range(a[0],0,-1):
                print(a[j])
            print(end='\n')
        # 不可以a.clear()
        
        else:
            list_r_from_n(n - 1, r - 1)

a[0]=r

def repeat(i):
    if i == 0:
    	return x
    else:
    	return f(repeat(i - 1))
return repeat

with_m = count_partitions(n-m,m)
without_m = count_partitions(n,m-1)
return with_m + without_m

def list_r_from_n(n, r):
    if r == 0:
        for j in range(a[0], 0, -1):
            print(a[j], end='')
        print(end='\n')
        return 0
    if n < r:
        return 0
    else:
        # 进入else，先把正在讨论的数固定住
        
        a[r] = n
        list_r_from_n(n - 1, r - 1)
        list_r_from_n(n - 1, r)

a[0] = r

def max_subseq(n, t):
    """Return the maximum subsequence of length at most t that can be found in the given number n."""
    
    if t == 0:
        return 0
    if n // 10 == 0:
        return n
    else:
        all_but_last, last = n // 10, n % 10
        return max(max_subseq(all_but_last, t - 1) * 10 + last, max_subseq(all_but_last, t))

curry2 = lambda f: lambda x: lambda y: f(x, y)

def powers(n, k):
    """Yield all powers of k whose digits appear in order in n."""
    def build(seed):
        """Yield all non-negative integers whose digits appear in order in seed.
        0 is yielded because 0 has no digits, so all its digits are in seed.
        """
        if seed == 0:
            yield 0
        else:
            for x in build(seed // 10):
                yield x
                yield x * 10 + seed % 10
    yield from filter(curry2(is_power)(k), build(n))

def factorize(n, k=2):
    if n == k:
        return 1
    elif n < k:
        return 0
    elif n % k != 0:
        return factorize(n, k + 1)
    return sum([factorize(n // k, k), factorize(n, k + 1)])

def increasing(n, smallest=10):
    if n == 0:
        return 0
    # 意味着可以使用当前的末位数字
    
    no = increasing(n // 10, smallest)
    if n % 10 < smallest:
        # 现在最小的数字变成了n%10
        
        yes = increasing(n // 10, n % 10) * 10 + n % 10
        return max(no, yes)
    else:
        return no

def cloase(n, smallest=10,d=10):
    if n == 0:
        return 0
    no = close(n, smallest,d)
    if n % 10 < smallest:
        yes = close(n // 10, min(smallest, d), n % 10) * 10 + n % 10
        return max(yes, no)
    return no

def count_coins(total):
    """Return the number of ways to make change for total using coins of value of 1"""
    
    def count_helper(total, m):
        if total == 0:
            return 1
        elif total < 0:
            return 0
        elif m is None:
            return 0
        elif total < m:
            return 0
        else:
            return count_helper(total - m, m) + count_helper(total, next_largest_coin(m))
    return count_helper(total, 1)

def pingpong(n):
    """Return the nth element of the ping-pong sequence."""
    
    if n <= 8:
        return n
    else:
        return pingpong(n - 1) + helper(n - 1)

# 决定是要+1还是-1

def helper(n):
    if n <= 7:
        return 1
    else:
        if n % 8 == 0 or num_eights(n) != 0:
            return -helper(n - 1)
        else:
            return helper(n - 1)

>>> fact = lambda n: 1 if n == 1 else mul(n, fact(sub(n, 1)))
>>> fact(5)
120

def make_anonymous_factorial():
    """Return the value of an expression that computes factorial."""
    
    return (lambda f: lambda n: f(f,n))(lambda s,x: 1 if x == 1 else mul(x, s(s,sub(x, 1))))

# 将原来的所有元素重复一遍并加上[2,7]元素

[2,7]+lists*2

pairs = [[1,2],[2,2],[3,4]]
for x,y in pairs:
if x == y:
	...

list(range(4))

def pawssible_patches(start, goal, limit):
    """A diff function that computes the edit distance from START to GOAL."""

    if limit < 0:
        return 0
    if start == '':
        return len(goal)
    elif goal == '':
        return len(start)
    elif start[0] == goal[0]:
        return pawssible_patches(start[1:], goal[1:],limit)
    else:
        limit -= 1
        add_diff = pawssible_patches(goal[0] + start, goal,limit)
        remove_diff = pawssible_patches(start[1:], goal,limit)
        substitute_diff = pawssible_patches(goal[0] + start[1:], goal,limit)
        return 1 + min(add_diff, remove_diff, substitute_diff)

elif start[0] == goal[0]:
	return pawssible_patches(start[1:], goal[1:],limit)

else:
    limit -= 1
    add_diff = pawssible_patches(goal[0] + start, goal,limit)
    remove_diff = pawssible_patches(start[1:], goal,limit)
    substitute_diff = pawssible_patches(goal[0] + start[1:], goal,limit)
    return 1 + min(add_diff, remove_diff, substitute_diff)

def align_skeleton(skeleton, code):
    """Aligns the given skeleton with the given code, minimizing the edit distance between the two."""
    skeleton, code = skeleton.replace(" ", ""), code.replace(" ", "")

    def helper_align(skeleton_idx, code_idx):
        """
        Aligns the given skeletal segment with the code.
        Returns (match, cost)
            match: the sequence of corrections as a string
            cost: the cost of the corrections, in edits
        """
        # 位于末尾且匹配
        
        if skeleton_idx == len(skeleton) and code_idx == len(code):
            return '', 0
        # 位于末尾且需要删除
        
        if skeleton_idx < len(skeleton) and code_idx == len(code):
            edits = "".join(["-[" + c + "]" for c in skeleton[skeleton_idx:]])
            return edits, len(skeleton) - skeleton_idx
        # 位于末尾且需要增加
        
        if skeleton_idx == len(skeleton) and code_idx < len(code):
            edits = "".join(["+[" + c + "]" for c in code[code_idx:]])
            return edits, len(code) - code_idx

        possibilities = []
        skel_char, code_char = skeleton[skeleton_idx], code[code_idx]
        # Match
        
        if skel_char == code_char:
            result, cost = helper_align(skeleton_idx + 1, code_idx + 1)
            new_result = skel_char + result
            possibilities.append((new_result, cost))
        # Insert
        
        result1, cost1 = helper_align(skeleton_idx, code_idx + 1)
        new_result1 = "+[" + code_char + "]" + result1
        possibilities.append((new_result1, 1 + cost1))
        # Delete
        
        result2, cost2 = helper_align(skeleton_idx + 1, code_idx)
        new_result2 = "-[" + skel_char + "]" + result2
        possibilities.append((new_result2, 1 + cost2))
        # 返回操作次数最少的情况
        
        return min(possibilities, key=lambda x: x[1])

    result, cost = helper_align(0, 0)
    return result

def decrypt(s, d):
    # base case 1:
    
    if s == '':
        return []
    ms = []
    # base case 2:
    
    if s in d:
        ms.append(d[s])
    # recursive case, make sure that at least 1 char at the front and the end:
    
    for k in range(1, len(d) - 1):
        first, suffix = s[:k], s[k:]
        if first in d:
            for rest in decrypt(suffix,d):
                ms.append(d[first] + ' ' + rest)
    return ms

def insert_into_all(item, nested_list):
    return [[item] + elem for elem in nested_list]

def subseqs(s):
        if not s:
        return [[]]
    else:
        return insert_into_all(s[0], subseqs(s[1:])) + subseqs(s[1:])

def inc_subseqs(s):
        def subseq_helper(s, prev):
        if not s:
            return [[]]
        elif s[0] < prev:
            return subseq_helper(s[1:], prev)
        else:
            # 用s[0]，那么需要更新prev的值为s[0]
            
            a = subseq_helper(s[1:], s[0])
            # 不用s[0]
            
            b = subseq_helper(s[1:], prev)
            return insert_into_all(s[0], a) + b

    return subseq_helper(s, 0)

def num_splits(s, d):
    def difference_so_far(s, difference):
        if not s:
            if abs(difference) <= d:
                return 1
           return 0
        element = s[0]
        s = s[1:]
        return difference_so_far(s, difference + element) + difference_so_far(s, difference - element)
    return difference_so_far(s, 0) // 2

def paths(x, y): 
    if x > y: 
        return [] 
    elif x == y: 
        return [[x]]
    else: 
        a = paths(x + 1, y) 
        b = paths(x * 2, y) 
        return [[x] + subpath for subpath in a + b]

>>> sum([[2,3],[4]],[])
[2,3,4]

>>> tree(3,[tree(1),tree(2,[tree(1),tree(1)])])
[3,[1],[2,[1],[1]]]

def tree(label, branches=[]):
    return [label] + branches

def label(tree):
    return tree[0]

def branches(tree):
    return tree[1:]

def is_tree(tree):
    if type(tree) != list or len(tree) < 1:
        return False
    for branch in branches(tree):
        # 这里的条件判断语句是有必要的，如果我们单单进行循环的话，最后势必会回到函数最下端的返回值那里，那判断也就失去了意义，通过if条件，程序在某一时刻直接结束
        
        if not is_tree(branch):
            return False
    return True

def is_leaf(tree):
    # 判断是否为empty
    
    return not branches(tree)

def fib_tree(n):
    if n <= 1:
        return tree(n)
    else:
        left, right = fib_tree(n-1), fib_tree(n-2)
        return tree(label(left)+label(right),[left,right])

def count_leaves(t):
    # 判断是否为叶结点，常作为base case
    
    if is_leaf(t):
        return 1
    else:
        branch_counts = [count_leaves(b) for b in branches(t)]
        return sum(branch_counts)
    
def leaves(tree):
    '''Return a list containing the leaf labels of tree.'''
    
    if is_leaf(tree):
        return [label(tree)]
    else:
        # 利用sum()函数对list操作的特殊性质，每次return遇到sum函数就会脱掉在sum内部的list comprehension外边一层括号,这样便可以保证输出的leaves都在同一维度内
        
        # List of leaf labels for each branch
        
        return sum([leaves(b) for b in branches(tree)],[])
    
def increment_leaves(t):
    '''Return a tree like t but with leaf labels incremented.'''
    
    if is_leaf(t):
        return tree(label(t) + 1)
    else:
        # 注意这里必须用tree包裹递归函数，如果没有tree，那么最后返回的仅仅就是几个单独的leaf，无法构成完整的树
        
        return tree(label(t),[increment_leaves(b) for b in branches(t)])
    
def increment(t):
    '''Return a tree like t but with all labels incremented'''
    
    # 递归结束条件为for循环终止，不需要单独设置base case
    
    return tree(label(t) + 1, [increment_leaves(b) for b in branches(t)])

def print_tree(t,indent = 0):
    print('	' * indent + str(label(t)))
    for b in branches(t):
        print_tree(b, indent + 1)

def add_trees(t1,t2):
    if is_leaf(t1) or is_leaf(t2):
        return tree(label(t1)+label(t2),branches(t1)+branches(t2))
    else:
        ......

else:
    return tree(label(t1)+label(t2),[add_trees(b[0],b[1]) for b in zip(branches(t1),branches(t2))])

else:
        branch_t1 = branches(t1)
        branch_t2 = branches(t2)
        t1_len = len(branch_t1)
        t2_len = len(branch_t2)
        if t1_len < t2_len:
            branch_t1 += [tree(0) for _ in range(t2_len-t1_len)]
        if t1_len > t2_len:
            branch_t2 += [tree(0) for _ in range(t1_len - t2_len)]

def add_trees(t1,t2):
    if is_leaf(t1) or is_leaf(t2):
        return tree(label(t1) + label(t2),branches(t1) + branches(t2))
    else:
        branch_t1 = branches(t1)
        branch_t2 = branches(t2)
        t1_len = len(branch_t1)
        t2_len = len(branch_t2)
        if t1_len < t2_len:
            branch_t1 += [tree(0) for _ in range(t2_len - t1_len)]
        if t1_len > t2_len:
            branch_t2 += [tree(0) for _ in range(t1_len - t2_len)]
        return tree(label(t1)+label(t2),[add_trees(b[0],b[1]) for b in zip(branch_t1,branch_t2)])

def find_path(tree,x):
    if label(tree) == x:
        return [x]

def find_path(tree,x):
    if label(tree) == x:
        return [x]
    for b in branches(tree):
        path = find_path(b,x)
        # 如果已经找到了x所在的位置，则返回，否则继续for循环遍历分支
        
        if path:
            return [label(tree)] + path

def prune_binary(t,nums):
    if is_leaf(t):
        if label(t) in nums:
            return t
        return None

next_branch = []
for b in branches(tree):
    cur_f = f(x)
    next_branch = next_branch + [cur_f]
return tree(label(tree),next_branch)

next_valid_nums = [n[1:] for n in nums if label(t) == nums[0]]

def prune_binary(t,nums):
    if is_leaf(t):
        if label(t) in nums:
            return t
        return None
    else:
        next_valid_nums = [n[1:] for n in nums if label(t) == nums[0]]
        next_branch = []
        for b in branches(tree):
            pruned_branch = pruned_binary(b,next_valid_nums)
            next_branch = next_branch + [pruned_branch]
        #此处的return语句必须独立于for循环之外，否则一条分支结束了就回家了
        
        return tree(label(tree),next_branch)

def prune_binary(t,nums):
    if is_leaf(t):
        if label(t) in nums:
            return t
        return None
    else:
        next_valid_nums = [n[1:] for n in nums if label(t) == nums[0]]
        next_branch = []
        for b in branches(tree):
            pruned_branch = pruned_binary(b,next_valid_nums)
            if pruned_branch is not None:
            	next_branch = next_branch + [pruned_branch]      
        if not new_branches:
            return None
        return tree(label(tree),next_branch)

def profit(t):
    '''Return the max profit'''
    
    return helper(t, False)

def helper(t, used_parent):
    # 如果已经使用了父节点,则下一个节点（该节点）不可使用，将flag设置为False就直接跳过这个if
    
    if used_parent:
        return sum([helper(b,False) for b in branches(t)])
    else:
        # 不使用父节点，分为用该节点/不用该节点两种情况，如果使用此节点，则下次递归（其子节点要跳过，即进入上边的if里）
        
        use_current_total = label(t) + sum([helper(b,True) for b in branches(t)])
        # 不使用此节点，则还需要考虑其子节点是否要使用，下次还要进入这里的else
        
        skip_current_label= 0        + sum([helper(b,False) for b in branches(t)])
        return max(use_current_total, skip_current_label)

def village(apple, t):
    '''Grafts the given branches 'bs' onto each leaf of the given tree 't', returning a new tree '''
    
    def graft(t,bs):
        if is_leaf(t):
            return tree(label(t), bs)
        new_branches = [graft(b,bs) for b in branches(t)]
        return tree(label(t), new_branches)
    base_t = apple(label(t))
    bs = [village(apple,b) for b in branches(t)]
    return graft(base_t,bs)

def village(apple, t):
    def graft(t, bs):
        # 叶结点
        
        if bs is None:
            return t
        new_branches = [tree(label(b), bs) for b in branches(base_t)]
        return tree(label(t), [tree(label(b), [village(apple, branch) for branch in branches(b)]) for b in new_branches])
    base_t = apple(label(t))
    bs = branches(t)
    return graft(base_t, bs)

def schedule(galaxy, sum_to, max_digit):
    def schedule_helper(galaxy, sum_sofar, index):
        if index == len(galaxy) and sum_sofar == sum_to:
            # 敏锐捕捉到，这个形式下返回的galaxy是完整的
            
            return [galaxy]
        elif sum_sofar > sum_to or (sum_sofar < sum_to and index == len(galaxy)):
            return []
        elif galaxy[index] != '?':
            return schedule_helper(galaxy, sum_sofar + int(galaxy[index]), index + 1)
        ans = []
        for x in range(max_digit + 1):
            # 关键的处理行
            
            modified_galaxy = galaxy[0:index] + str(x) + galaxy[index + 1:]
            ans = ans + schedule_helper(modified_galaxy, sum_sofar + x, index + 1)
        return ans

    return schedule_helper(galaxy, 0, 0)

def print_all_paths(t):
    '''Print all the paths from the root to a leaf'''
    for path in all_paths(t):
        print(path)

def all_paths(t):
    if is_leaf(t):
        yield [label(t)]
    for b in branches(t):
        # What should be done next?

def all_paths(t):
    if is_leaf(t):
        yield [label(t)]
    for b in branches(t):
        for path in all_paths(b):
            yield [label(t)] + path

def all_paths2(res,t):
    res.append(label(t))
    if is_leaf(t):
        return [res]
    else:
        ans = []
        for b in branches(t):
            ans += all_paths(res.copy(),b)
           return ans

s = [2,3]
t = [5,6]
a = s + [t]
b = a[1:]
a[1] = 9
b[1][1] = 0

>>> s
[2,3]
>>> t
[5,0]
>>> a
[2,9,[5,0]]
>>> b
[3,[5,0]]

s[0:0] = t

def make_withdraw(balance):
    def withdraw(amount):
        nonlocal balance
        if amount > balance:
            return 'Insufficient funds'
        balance = balance - amount
        return balance
    return withdraw

wd = make_withdraw(20)
print(wd(5))

s = [[1,2],3,4,5]
t = iter(s)
next(t)
next(t)
>>> list(t)
[4,5]

d = {'one':1,'two':2}
k=iter(d)
next(k)
# 下边这句会报错，dictionary changed size during iteration

d['zero'] = 0

def plus_minus(x):
    yield x
    yield -x

t = plus_minus(3)
>>> next(t)
3
>>> next(t)
-3

def prefixes(s):
    if s:
        yield from prefixes(s[:-1])
        yield s

def prefixes(s):
    if s:
        for x in prefixes(s[:-1]):
            yield x
        yield s

def prefixes(s):
    result = []
    if s:
        for x in prefixes(s[:-1]):
            result.append(x)
        result.append(s)
    return result

def permutations(seq):
    # base case
    
    if not seq:
    	yield []
    else:
        # 先选定第一个位置
        
        for i in range(len(seq)):
            start = seq[i]
            # 也可以写成：rest = [seq[j] for j in range(len(s)) if i != j]
            
            rest = seq[:i] + seq[i+1:]
            for rest_permutation in premutations(rest):
                yield [start] + rest_permutation        

def permutations(seq):
    if not seq:
        yield []
    else:
        first = seq[0]
        rest = seq[1:]
        for rest_permutation in permutations(rest):
            # 选空插入
            
            for i in range(len(seq)):
                yield rest_permutation[:i] + [first] + rest_permutation[i:]
                # 或者写作：
                
                result = list(rest_permutation)
                result.insert(i,first)
                yield result

def filter_link(link, f):
    if link is Link.empty:
        yield Link.empty
    # 不会如期执行if语句    
        
    if f(link.first):
        yield link.first
        filter_link(link.rest, f)
    else:
        filter_link(link.rest, f)


link = Link(1, Link(2, Link(3)))
g = filter_link(link, lambda x: x % 2 == 0)
next(g)