<|instruction|>
Solve the below problem. The solution should start with an abridged problem statement. Then key observations. Then full solution based on the observations. Then C++ and Python implementations with comments.

534. Computer Network
Time limit per test: 1 second(s)
Memory limit: 262144 kilobytes
input: standard
output: standard

Computer network of Berland's best physical and mathematical school has a "tree" topology. That is, the network has no cycles; it connects n computers by n-1 cables. Each cable connects exactly two different computers.

The school has really old equipment and the network is slow. The network administrator defined for each cable a value ti, which represents the average time to transmit a packet from computer ai to computer bi (or vice versa), where ai, bi are computers connected by the i-th cable.

For two computers a and b the average time to transmit a packet from one computer to another is the sum of all ti's for the cables on the path from a to b. Of course, an important characteristic of the network is the maximum possible average time of transmitting a packet between two computers. This characteristic is called .

In light of national innovations and modernizations it was decided to improve the school computer network and reduce the value of .

It was decided to replace some cables with new ones. New cables have such a high speed of data transmission that any packet passes through the cable in negligibly little time. In practice, the time of a packet transmission for new cables equals 0. For each cable its price pi was determined — the cost of replacing the i-th cable by the new one. Of course, after replacing the i-th cable, the new one will still connect computers ai and bi.

Help the network administrator to find such set of cables, that after they are replaced, the value of  becomes less and the total cost of replacing these cables is minimal. Note that in this problem you do not have to minimize , but you should make it less than its initial value.

Input
The first line contains a single integer n (2 ≤ n ≤ 105), n is the number of computers in the network. Then n-1 lines contain descriptions of all cables in the form of four integers ai, bi, ti, pi (1 ≤ ai,bi ≤ n; 1 ≤ ti,pi ≤ 104), where ai,bi are numbers of computers connected by the i-th cable, ti is the average transmission time of a packet through the cable and pi is the cost of replacing the i-th cable with a new one.

Output
In the first line print the required minimum possible cost of replacements. In the second line print the number of cables in the required set in arbitrary order. In the third line print the numbers of these cables. Consider the cables numbered from 1 in the order they appear in the input. If there are multiple solutions, print any of them.

Example(s)
sample input
sample output
4
1 2 3 3
1 3 8 33
1 4 3 7
10
2
1 3

sample input
sample output
4
1 2 3 5
2 3 5 2
3 4 5 4
2
1
2

<|response|>
## 1) Abridged problem statement (concise)

You are given a weighted tree with `n` nodes and `n-1` edges.
Edge `i` has:
- transmission time `t_i` (used in path length sums),
- replacement cost `p_i`.

If you replace an edge, its time becomes `0` (endpoints unchanged).

Let `D` be the **original diameter** of the tree (maximum path sum of `t_i`).
Choose a set of edges to replace so that the **new diameter is strictly less than `D`**, with **minimum total replacement cost**.

Output:
- minimum cost,
- number of replaced edges,
- their indices (1-based, in any order).

Constraints: `n ≤ 1e5`.

---

## 2) Key observations

1. **Replacing edges only decreases path lengths.**
   So the new diameter `< D` iff **no path of length exactly `D` survives** after replacements.

2. The diameter in a rooted tree can be threatened in two ways:
   - A **single downward path** of length `D` from some node to a leaf remains.
   - A **path passing through a node `u`**, formed by combining two downward paths from different children, reaches `D`.

3. Root the tree at node `1` and define:
   - `depth[u] = max distance (by times) from u down to any node in its subtree`.
   This is computable by one DFS.

4. We need a DP that, for every subtree, either:
   - forces its best downward path to become **strictly smaller** than before (so it can't contribute to any original-diameter path), or
   - allows keeping the best depth, but ensures **no diameter-length path is created inside** or **through** the current node.

---

## 3) Full solution approach

### Step A — Compute the original diameter `D`
Use the classic "two farthest nodes" method:
1. Traverse from node `1` to find farthest node `u`.
2. Traverse from `u` to find farthest node `v`.
3. Distance `dist(u, v)` is the diameter `D`.

Because it's a tree, you can do a simple queue/stack traversal accumulating distances.

---

### Step B — Root the tree and compute `depth[u]`
Root at `1`. Compute:

\[
depth[u] = \max_{child\ c} (depth[c] + w(u,c))
\]

where `w(u,c) = t_edge`.

---

### Step C — DP states
For each node `u`, compute two values:

- `dp0[u]`: minimum cost to modify edges in subtree of `u` so that
  **the maximum downward path from `u` becomes strictly less than the original `depth[u]`**.

- `dp1[u]`: minimum cost so that
  **the maximum downward path from `u` remains exactly `depth[u]`**, but after modifications:
  - no path of length `D` exists completely inside this subtree,
  - and no diameter path of length `D` is formed **through** `u`.

Leaf base case:
- `depth[leaf]=0`
- `dp1[leaf]=0` (keep depth 0)
- `dp0[leaf]=INF` (cannot make depth < 0)

---

### Step D — Child handling: "keep" vs "reduce"
For a child `c` of `u` over edge with time `w` and cost `p`:

Child contributes:

\[
contrib = depth[c] + w
\]

To **keep** this contribution unchanged, we must keep child's depth:
- `cost_keep(c) = dp1[c]`

To **reduce** this contribution (make it smaller than before), we have two options:
1. Reduce inside child subtree:
   - cost `dp0[c]`
2. Replace edge `(u,c)` so `w` becomes `0`:
   - cost `p + min(dp0[c], dp1[c])`

So:

\[
cost\_reduce(c)=\min(dp0[c],\ p+\min(dp0[c],dp1[c]))
\]

---

### Step E — Transition for `dp0[u]` (force depth smaller)
To make the resulting depth at `u` strictly smaller than `depth[u]`,
**every child that achieves the maximum** (`contrib == depth[u]`) must be reduced.

Other children can be reduced or kept, whichever is cheaper.

---

### Step F — Transition for `dp1[u]` (keep depth, forbid diameter)
If `depth[u] == D`, then keeping that depth means there's still a downward path of length `D`, so diameter remains `D`. Hence:

- `dp1[u] = INF` if `depth[u] == D`.

Otherwise, let `first` and `second` be the largest two `contrib` values among children.

- If `first + second < D`, no diameter can pass through `u`.
  We just need to ensure **at least one max child is kept** so depth stays `depth[u]`.

- If `first + second >= D`, a diameter through `u` is possible.
  Let:

\[
threshold = D - depth[u]
\]

Any child with `contrib >= threshold` is "dangerous": if we keep it while also keeping the max path, we can create a length-`D` path through `u`.
So in `dp1[u]` we reduce all dangerous children, except we must still **keep one max child** to maintain depth.

All of this is doable in linear total time by scanning children a constant number of times.

---

### Step G — Reconstruction
After DP, pick best root state:

- answer = `min(dp0[1], dp1[1])`

Then run a second DFS that repeats the same choices and records which edges were replaced.

---

### Complexity
- Time: `O(n)`
- Memory: `O(n)`

---

## 4) C++ implementation

```cpp
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

const int64_t inf = (int64_t)1e18 + 42;

int n;
vector<vector<tuple<int, int, int>>> adj;
vector<int> prices;

void read() {
    cin >> n;
    adj.resize(n + 1);
    prices.resize(n - 1);
    for(int i = 0; i < n - 1; i++) {
        int a, b, t, p;
        cin >> a >> b >> t >> p;
        adj[a].push_back({b, t, i});
        adj[b].push_back({a, t, i});
        prices[i] = p;
    }
}

void solve() {
    // The problem asks to find the least sum of costs of edges that we can
    // replace so that the diameter of the tree decreases. We root the tree
    // and compute depth[u] = max distance to any leaf in subtree u. Then we
    // find the diameter D. The DP is:
    //
    //   dp[u][0] = min cost so depth of subtree < depth[u] (can't participate
    //              in any diameter anymore)
    //
    //   dp[u][1] = min cost so depth of subtree == depth[u] (but no diameter
    //              formed through u)
    //
    // When merging children at u, if two children could form a path of length
    // D through u, we must reduce at least one. If depth[u] == D, then keeping
    // full depth means the diameter is still D, so dp[u][1] = inf.
    // There is a fair bit of case work, but overall the complexity ends up
    // being O(n).

    if(n == 2) {
        cout << prices[0] << "\n1\n1\n";
        return;
    }

    auto bfs = [&](int start) {
        vector<int64_t> dist(n + 1, -1);
        queue<int> q;
        q.push(start);
        dist[start] = 0;
        while(!q.empty()) {
            int cur = q.front();
            q.pop();
            for(auto& [nb, t, idx]: adj[cur]) {
                if(dist[nb] == -1) {
                    dist[nb] = dist[cur] + t;
                    q.push(nb);
                }
            }
        }
        return dist;
    };

    auto d1 = bfs(1);
    int u = 1;
    for(int i = 2; i <= n; i++) {
        if(d1[i] > d1[u]) {
            u = i;
        }
    }

    auto dist_u = bfs(u);
    int v = u;
    for(int i = 1; i <= n; i++) {
        if(dist_u[i] > dist_u[v]) {
            v = i;
        }
    }

    int64_t D = dist_u[v];

    vector<int64_t> depth(n + 1, 0);
    vector<int> parent(n + 1, -1);
    vector<int> parent_edge(n + 1, -1);
    vector<int> parent_weight(n + 1, 0);

    function<void(int, int)> calc_depth = [&](int cur, int par) {
        parent[cur] = par;
        for(auto& [nb, w, idx]: adj[cur]) {
            if(nb != par) {
                parent_edge[nb] = idx;
                parent_weight[nb] = w;
                calc_depth(nb, cur);
                depth[cur] = max(depth[cur], depth[nb] + w);
            }
        }
    };
    calc_depth(1, -1);

    vector<int64_t> dp0(n + 1), dp1(n + 1);
    function<void(int, int)> dfs = [&](int cur, int par) {
        vector<tuple<int64_t, int64_t, int, int, int>> children;
        for(auto& [nb, w, idx]: adj[cur]) {
            if(nb != par) {
                dfs(nb, cur);
                int64_t contrib = depth[nb] + w;
                children.push_back({contrib, w, prices[idx], nb, idx});
            }
        }

        if(children.empty()) {
            dp0[cur] = inf;
            dp1[cur] = 0;
            return;
        }

        int64_t first_contrib = 0, second_contrib = 0;
        for(auto& [contrib, w, price, child, idx]: children) {
            if(contrib > first_contrib) {
                second_contrib = first_contrib;
                first_contrib = contrib;
            } else if(contrib > second_contrib) {
                second_contrib = contrib;
            }
        }

        auto cost_reduce = [&](int64_t contrib, int64_t w, int price,
                               int child) -> int64_t {
            int64_t opt1 = dp0[child];
            int64_t opt2 =
                (w > 0) ? (price + min(dp0[child], dp1[child])) : inf;
            return min(opt1, opt2);
        };

        auto cost_keep = [&](int child) -> int64_t { return dp1[child]; };

        dp0[cur] = 0;
        for(auto& [contrib, w, price, child, idx]: children) {
            if(contrib == depth[cur]) {
                dp0[cur] += cost_reduce(contrib, w, price, child);
            } else {
                dp0[cur] +=
                    min(cost_reduce(contrib, w, price, child),
                        cost_keep(child));
            }
        }

        if(depth[cur] == D) {
            dp1[cur] = inf;
        } else if(first_contrib + second_contrib < D) {
            int64_t base = 0;
            int64_t min_delta = inf;
            for(auto& [contrib, w, price, child, idx]: children) {
                int64_t cr = cost_reduce(contrib, w, price, child);
                int64_t ck = cost_keep(child);
                base += min(cr, ck);
                if(contrib == depth[cur]) {
                    min_delta = min(min_delta, ck - min(cr, ck));
                }
            }
            dp1[cur] = base + min_delta;
        } else {
            int64_t threshold = D - depth[cur];
            int64_t base = 0;
            for(auto& [contrib, w, price, child, idx]: children) {
                if(contrib >= threshold) {
                    base += cost_reduce(contrib, w, price, child);
                } else {
                    base +=
                        min(cost_reduce(contrib, w, price, child),
                            cost_keep(child));
                }
            }
            int64_t min_delta = inf;
            for(auto& [contrib, w, price, child, idx]: children) {
                if(contrib == depth[cur]) {
                    int64_t cr = cost_reduce(contrib, w, price, child);
                    int64_t ck = cost_keep(child);
                    min_delta = min(min_delta, ck - cr);
                }
            }
            dp1[cur] = base + min_delta;
        }
    };

    dfs(1, -1);

    int64_t ans = min(dp0[1], dp1[1]);
    int target_state = (dp0[1] <= dp1[1]) ? 0 : 1;

    vector<int> cut_edges;

    function<void(int, int, int)> reconstruct = [&](int cur, int par,
                                                    int state) {
        vector<tuple<int64_t, int64_t, int, int, int>> children;
        for(auto& [nb, w, idx]: adj[cur]) {
            if(nb != par) {
                int64_t contrib = depth[nb] + w;
                children.push_back({contrib, w, prices[idx], nb, idx});
            }
        }

        if(children.empty()) {
            return;
        }

        int64_t first_contrib = 0, second_contrib = 0;
        for(auto& [contrib, w, price, child, idx]: children) {
            if(contrib > first_contrib) {
                second_contrib = first_contrib;
                first_contrib = contrib;
            } else if(contrib > second_contrib) {
                second_contrib = contrib;
            }
        }

        auto cost_reduce = [&](int64_t contrib, int64_t w, int price,
                               int child) -> int64_t {
            int64_t opt1 = dp0[child];
            int64_t opt2 =
                (w > 0) ? (price + min(dp0[child], dp1[child])) : inf;
            return min(opt1, opt2);
        };

        auto cost_keep = [&](int child) -> int64_t { return dp1[child]; };

        auto do_reduce = [&](int64_t contrib, int64_t w, int price, int child,
                             int idx) {
            int64_t opt1 = dp0[child];
            int64_t opt2 =
                (w > 0) ? (price + min(dp0[child], dp1[child])) : inf;
            if(opt1 <= opt2) {
                reconstruct(child, cur, 0);
            } else {
                cut_edges.push_back(idx);
                if(dp0[child] <= dp1[child]) {
                    reconstruct(child, cur, 0);
                } else {
                    reconstruct(child, cur, 1);
                }
            }
        };

        auto do_opt = [&](int64_t contrib, int64_t w, int price, int child,
                          int idx) {
            int64_t cr = cost_reduce(contrib, w, price, child);
            int64_t ck = cost_keep(child);
            if(ck <= cr) {
                reconstruct(child, cur, 1);
            } else {
                do_reduce(contrib, w, price, child, idx);
            }
        };

        if(state == 0) {
            for(auto& [contrib, w, price, child, idx]: children) {
                if(contrib == depth[cur]) {
                    do_reduce(contrib, w, price, child, idx);
                } else {
                    do_opt(contrib, w, price, child, idx);
                }
            }
        } else {
            if(first_contrib + second_contrib < D) {
                int keep_child = -1;
                int64_t min_delta = inf;
                for(auto& [contrib, w, price, child, idx]: children) {
                    if(contrib == depth[cur]) {
                        int64_t cr = cost_reduce(contrib, w, price, child);
                        int64_t ck = cost_keep(child);
                        int64_t delta = ck - min(cr, ck);
                        if(delta < min_delta) {
                            min_delta = delta;
                            keep_child = child;
                        }
                    }
                }
                for(auto& [contrib, w, price, child, idx]: children) {
                    if(child == keep_child) {
                        reconstruct(child, cur, 1);
                    } else {
                        do_opt(contrib, w, price, child, idx);
                    }
                }
            } else {
                int64_t threshold = D - depth[cur];
                int keep_child = -1;
                int64_t min_delta = inf;
                for(auto& [contrib, w, price, child, idx]: children) {
                    if(contrib == depth[cur]) {
                        int64_t cr = cost_reduce(contrib, w, price, child);
                        int64_t ck = cost_keep(child);
                        if(ck - cr < min_delta) {
                            min_delta = ck - cr;
                            keep_child = child;
                        }
                    }
                }
                for(auto& [contrib, w, price, child, idx]: children) {
                    if(child == keep_child) {
                        reconstruct(child, cur, 1);
                    } else if(contrib >= threshold) {
                        do_reduce(contrib, w, price, child, idx);
                    } else {
                        do_opt(contrib, w, price, child, idx);
                    }
                }
            }
        }
    };

    reconstruct(1, -1, target_state);

    cout << ans << "\n" << cut_edges.size() << "\n";
    for(int i = 0; i < (int)cut_edges.size(); i++) {
        if(i > 0) {
            cout << " ";
        }
        cout << cut_edges[i] + 1;
    }
    cout << " \n";
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}
```

---

## 5) Python implementation (detailed comments)

```python
import sys
sys.setrecursionlimit(300000)

INF = 10**30

def solve():
    input = sys.stdin.readline
    n = int(input().strip())

    # adjacency list: adj[u] = list of (v, time, edge_index)
    adj = [[] for _ in range(n + 1)]
    prices = [0] * (n - 1)

    for i in range(n - 1):
        a, b, t, p = map(int, input().split())
        adj[a].append((b, t, i))
        adj[b].append((a, t, i))
        prices[i] = p

    # Special case n==2: only one edge, must replace it to reduce diameter.
    if n == 2:
        print(prices[0])
        print(1)
        print(1)
        return

    # Tree "BFS": since it's a tree, we can do a stack/queue traversal
    # to compute distances without priority queue.
    from collections import deque
    def bfs(start: int):
        dist = [-1] * (n + 1)
        q = deque([start])
        dist[start] = 0
        while q:
            u = q.popleft()
            for v, w, ei in adj[u]:
                if dist[v] == -1:
                    dist[v] = dist[u] + w
                    q.append(v)
        return dist

    # Compute diameter endpoints and length D
    d1 = bfs(1)
    u = max(range(1, n + 1), key=lambda i: d1[i])
    du = bfs(u)
    v = max(range(1, n + 1), key=lambda i: du[i])
    D = du[v]

    # Root tree at 1 and compute depth[u] = best downward distance.
    depth = [0] * (n + 1)
    parent = [-1] * (n + 1)

    def calc_depth(u: int, p: int):
        parent[u] = p
        best = 0
        for v, w, ei in adj[u]:
            if v == p:
                continue
            calc_depth(v, u)
            best = max(best, depth[v] + w)
        depth[u] = best

    calc_depth(1, -1)

    dp0 = [INF] * (n + 1)
    dp1 = [INF] * (n + 1)

    def dfs(u: int, p: int):
        children = []  # list of (contrib, w, price, child, edge_index)
        for v, w, ei in adj[u]:
            if v == p:
                continue
            dfs(v, u)
            children.append((depth[v] + w, w, prices[ei], v, ei))

        # Leaf
        if not children:
            dp0[u] = INF  # cannot reduce below 0
            dp1[u] = 0    # keep depth 0
            return

        # Find largest and second largest contrib
        first = 0
        second = 0
        for contrib, w, price, v, ei in children:
            if contrib > first:
                second = first
                first = contrib
            elif contrib > second:
                second = contrib

        def cost_reduce(contrib, w, price, v):
            # Option 1: reduce inside child's subtree => dp0[v]
            opt1 = dp0[v]
            # Option 2: replace edge (u,v), making w=0 => pay price,
            # then child can be in cheaper of dp0/dp1.
            opt2 = price + min(dp0[v], dp1[v])
            return opt1 if opt1 < opt2 else opt2

        def cost_keep(v):
            return dp1[v]

        # dp0[u]: force resulting depth strictly smaller than original depth[u]
        total = 0
        for contrib, w, price, v, ei in children:
            if contrib == depth[u]:
                total += cost_reduce(contrib, w, price, v)
            else:
                cr = cost_reduce(contrib, w, price, v)
                ck = cost_keep(v)
                total += cr if cr < ck else ck
        dp0[u] = total

        # dp1[u]: keep depth[u] but avoid any diameter D appearing
        if depth[u] == D:
            dp1[u] = INF
        elif first + second < D:
            base = 0
            min_delta = INF
            for contrib, w, price, v, ei in children:
                cr = cost_reduce(contrib, w, price, v)
                ck = cost_keep(v)
                m = cr if cr < ck else ck
                base += m
                if contrib == depth[u]:
                    # extra cost to force keep on a max child
                    min_delta = min(min_delta, ck - m)
            dp1[u] = base + min_delta
        else:
            threshold = D - depth[u]
            base = 0
            for contrib, w, price, v, ei in children:
                if contrib >= threshold:
                    base += cost_reduce(contrib, w, price, v)
                else:
                    cr = cost_reduce(contrib, w, price, v)
                    ck = cost_keep(v)
                    base += cr if cr < ck else ck

            min_delta = INF
            for contrib, w, price, v, ei in children:
                if contrib == depth[u]:
                    cr = cost_reduce(contrib, w, price, v)
                    ck = cost_keep(v)
                    min_delta = min(min_delta, ck - cr)
            dp1[u] = base + min_delta

    dfs(1, -1)

    # Choose best state at root
    if dp0[1] <= dp1[1]:
        ans = dp0[1]
        root_state = 0
    else:
        ans = dp1[1]
        root_state = 1

    cut_edges = []

    def reconstruct(u: int, p: int, state: int):
        children = []
        for v, w, ei in adj[u]:
            if v == p:
                continue
            children.append((depth[v] + w, w, prices[ei], v, ei))

        if not children:
            return

        first = 0
        second = 0
        for contrib, w, price, v, ei in children:
            if contrib > first:
                second = first
                first = contrib
            elif contrib > second:
                second = contrib

        def cost_reduce(contrib, w, price, v):
            opt1 = dp0[v]
            opt2 = price + min(dp0[v], dp1[v])
            return opt1 if opt1 < opt2 else opt2

        def cost_keep(v):
            return dp1[v]

        def do_reduce(contrib, w, price, v, ei):
            opt1 = dp0[v]
            opt2 = price + min(dp0[v], dp1[v])
            if opt1 <= opt2:
                reconstruct(v, u, 0)
            else:
                cut_edges.append(ei)
                reconstruct(v, u, 0 if dp0[v] <= dp1[v] else 1)

        def do_opt(contrib, w, price, v, ei):
            cr = cost_reduce(contrib, w, price, v)
            ck = cost_keep(v)
            if ck <= cr:
                reconstruct(v, u, 1)
            else:
                do_reduce(contrib, w, price, v, ei)

        if state == 0:
            for contrib, w, price, v, ei in children:
                if contrib == depth[u]:
                    do_reduce(contrib, w, price, v, ei)
                else:
                    do_opt(contrib, w, price, v, ei)
        else:
            if first + second < D:
                keep_child = -1
                min_delta = INF
                for contrib, w, price, v, ei in children:
                    if contrib == depth[u]:
                        cr = cost_reduce(contrib, w, price, v)
                        ck = cost_keep(v)
                        m = cr if cr < ck else ck
                        delta = ck - m
                        if delta < min_delta:
                            min_delta = delta
                            keep_child = v

                for contrib, w, price, v, ei in children:
                    if v == keep_child:
                        reconstruct(v, u, 1)
                    else:
                        do_opt(contrib, w, price, v, ei)
            else:
                threshold = D - depth[u]
                keep_child = -1
                min_delta = INF
                for contrib, w, price, v, ei in children:
                    if contrib == depth[u]:
                        cr = cost_reduce(contrib, w, price, v)
                        ck = cost_keep(v)
                        if ck - cr < min_delta:
                            min_delta = ck - cr
                            keep_child = v

                for contrib, w, price, v, ei in children:
                    if v == keep_child:
                        reconstruct(v, u, 1)
                    elif contrib >= threshold:
                        do_reduce(contrib, w, price, v, ei)
                    else:
                        do_opt(contrib, w, price, v, ei)

    reconstruct(1, -1, root_state)

    # Output
    print(ans)
    print(len(cut_edges))
    # Convert to 1-based indices
    if cut_edges:
        print(" ".join(str(ei + 1) for ei in cut_edges))
    else:
        print()

if __name__ == "__main__":
    solve()
```
