def equal_vec_done_cont(a, b, idx, info, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    eq = check_one_val(_vals)
    if eq is values.w_false:
        return return_value(values.w_false, env, cont)
    inc = idx + 1
    return equal_vec_func(a, b, inc, info, env, cont)

def get_port_cont(prop, typ, env, cont, _vals):
    from pycket.interpreter import return_value, check_one_val
    val = check_one_val(_vals)
    if isinstance(val, values_struct.W_RootStruct):
        return get_port(val, prop, typ, env, cont)
    else:
        return return_value(val, env, cont)

def proc_arity_cont(arity, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    val = check_one_val(_vals)
    if not arity.arity_list:
        return return_value(val, env, cont)
    result = make_arity_list(arity, val)
    return return_value(result, env, cont)

def catch_set_is_equal_cont(data, idx, key, val, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    cmp = check_one_val(_vals)
    if cmp is not values.w_false:
        data[idx] = (key, val)
        return return_value(values.w_void, env, cont)
    return equal_hash_set_loop(data, idx + 1, key, val, env, cont)

def imp_struct_set_cont(orig_struct, setter, field, app, env, cont, _vals):
    from pycket.interpreter import check_one_val

    val = check_one_val(_vals)
    if setter is values.w_false:
        return orig_struct.set_with_extra_info(field, val, app, env, cont)
    return setter.call_with_extra_info([orig_struct, val], env, cont, app)

def catch_equal_cont(vals, args, idx, env, cont, _vals):
    from pycket.interpreter import check_one_val

    val = check_one_val(_vals)
    if val is values.w_false:
        raise SchemeException("Expecting original value or chaperone")
    return check_chaperone_results_loop(vals, args, idx + 1, env, cont)

def equal_ht_done_cont(hash_1_items, hash_2, idx, info, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    eq = check_one_val(_vals)
    if eq is values.w_false:
        return return_value(values.w_false, env, cont)
    inc = idx + 1
    return equal_ht_func(hash_1_items, hash_2, inc, info, env, cont)

def hash_keys_subset_huh_cont(keys_vals, hash_2, idx, env, cont, _vals):
    from pycket.interpreter import return_value, check_one_val
    val = check_one_val(_vals)
    if val is values.w_false:
        return return_value(values.w_false, env, cont)
    else:
        return hash_keys_subset_huh_loop(keys_vals, hash_2, idx + 1, env, cont)

def imp_hash_table_post_ref_cont(post, ht, old, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_multi_vals
    val = check_one_val(_vals)
    if val is None:
        # XXX this looks wrong, check_one_val raises if there are multiple
        # values
        return return_multi_vals(_vals, env, cont)
    return post.call([ht, old, val], env, cont)

def equal_ht_cont(hash_1_items, hash_2, idx, info, env, cont, _vals):
    from pycket.interpreter import return_value, check_one_val
    hash_2_val = check_one_val(_vals)
    if hash_2_val is values.w_false:
        return return_value(values.w_false, env, cont)
    else:
        return equal_func(hash_1_items[idx][1], hash_2_val, info, env,
                          equal_ht_done_cont(hash_1_items, hash_2, idx, info, env, cont))

def vec2val_cont(vals, vec, n, s, l, env, cont, new_vals):
    from pycket.interpreter import return_multi_vals, check_one_val
    new  = check_one_val(new_vals)
    vals[n] = new
    if s+n+1 == l:
        return return_multi_vals(values.Values.make(vals), env, cont)
    else:
        return vec.vector_ref(values.W_Fixnum.make(s+n+1), env, vec2val_cont(vals, vec, n+1, s, l, env, cont))

def vector_copy_cont_get(src, src_start, src_end, dest, dest_start, i, env, cont, _vals):
    from pycket.interpreter import check_one_val
    val  = check_one_val(_vals)
    idx  = values.W_Fixnum(i.value + dest_start)
    next = values.W_Fixnum(i.value + 1)
    return dest.vector_set(idx, val, env,
                goto_vector_copy_loop(src, src_start, src_end,
                    dest, dest_start, next, env, cont))

def display_escape_cont(exn, env, cont, _vals):
    from pycket.interpreter import check_one_val
    message = check_one_val(_vals)

    display_handler = error_display_handler_param.get(cont) # parameterize this to default first
    escape_handler = error_escape_handler_param.get(cont) # this one too

    # display, then escape
    return display_handler.call([message, exn], env, call_handler_cont(escape_handler, [], env, cont))

def read_stream_cont(env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    port = check_one_val(_vals)
    rt = current_readtable_param.get(cont)
    if rt is values.w_false:
        rt = None
    else:
        assert isinstance(rt, values.W_ReadTable)
    return read_stream_rt(port, rt, env, cont)

def hash_ref_cont(default, env, cont, _vals):
    from pycket.interpreter import return_value, check_one_val
    val = check_one_val(_vals)
    if val is not w_missing:
        return return_value(val, env, cont)
    if default is None:
        raise SchemeException("key not found")
    if default.iscallable():
        return default.call([], env, cont)
    return return_value(default, env, cont)

def ormap_cont(f, ls, env, cont, vals):
    # XXX this is currently not properly jitted
    from pycket.interpreter import return_value, check_one_val
    val = check_one_val(vals)
    if val is values.w_true:
        return return_value(val, env, cont)
    for l in ls:
        if l is values.w_null:
            return return_value(values.w_false, env, cont)
    cars = [l.car() for l in ls]
    cdrs = [l.cdr() for l in ls]
    return f.call(cars, env, ormap_cont(f, cdrs, env, cont))

def hash_map_cont(f, ht, index, w_acc, env, cont, vals):
    from pycket.interpreter import return_value, check_one_val
    w_val = check_one_val(vals)
    if w_val is not w_missing:
        w_acc = values.W_Cons.make(w_val, w_acc)
    nextindex = index + 1
    try:
        w_key, w_value = ht.get_item(index)
    except KeyError:
        return return_value(w_missing, env,
                hash_map_cont(f, ht, nextindex, w_acc, env, cont))
    except IndexError:
        return return_value(w_acc, env, cont)
    after = hash_map_cont(f, ht, nextindex, w_acc, env, cont)
    return f.call([w_key, w_value], env, after)

def do_read_line(mode, as_bytes, env, cont, _vals):
    # FIXME: respect mode
    from pycket.interpreter import return_value, check_one_val
    port = check_one_val(_vals)
    line = port.readline()
    stop = len(line) - 1
    if stop >= 0:
        # chomp
        if line[stop] == "\n":
            line = line[:stop]
        if as_bytes:
            return return_value(values.W_Bytes.from_string(line), env, cont)
        else:
            return return_value(values_string.W_String.fromstr_utf8(line), env, cont)
    else:
        return return_value(values.eof_object, env, cont)

def check_cont(proc, v, v1, v2, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    val = check_one_val(_vals)
    if val is not values.w_false:
        return return_value(v._ref(1), env, cont)
    return proc.call([v, v1, v2], env, cont)

def imp_cmk_post_set_cont(body, inner, env, cont, _vals):
    from pycket.interpreter import check_one_val
    val = check_one_val(_vals)
    return inner.set_cmk(body, val, cont, env, cont)