cout << fixed << setprecision(2) << num << '\n';

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 5;
string s;
int n;
void solve() {

}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    int T = 1;
    // cin >> T;
    while(T--) solve();
}

#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
namespace INPUT{
    char buf[1 << 20], *p1, *p2;
    #define gc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?EOF:*p1++)
}
using namespace INPUT;
template<typename T>
inline T read(){
    T x = 0, p = 1;
    char ch = gc();
    for(; ch < '0' || ch > '9'; ch = gc())
        if(ch == '-') p = -1;
    for(;ch >= '0' && ch <= '9'; ch = gc())
        x = (x<<3) + (x<<1) + (ch^48);
    return x * p;
}
void solve(){
    // ...
}
int main(){
    freopen("A.in", "r", stdin);
    freopen("A.out", "w", stdout);
    int T = read<int>();
    while(T--) solve();
}

// 带权并查集（a[x] = a[y] + d; 模 M）
struct DSU {
  std::vector<size_t> pa, size, dist;

  explicit DSU(size_t size_) : pa(size_), size(size_, 1), dist(size_) {
    std::iota(pa.begin(), pa.end(), 0);
  }

  size_t find(size_t x) {
    if (pa[x] == x) return x;
    size_t y = find(pa[x]);
    (dist[x] += dist[pa[x]]) %= M;
    return pa[x] = y;
  }

  bool unite(size_t x, size_t y, int d) { // a[x] = a[y] + d;
    find(x), find(y);
    (d += M - dist[y]) %= M;
    (d += dist[x]) %= M;
    x = pa[x], y = pa[y];
    if (x == y) return d == 0;
    if (size[x] < size[y]) {
      std::swap(x, y);
      d = (M - d) % M;
    }
    pa[y] = x;
    size[x] += size[y];
    dist[y] = d;
    return true;
  }

  int check(size_t x, size_t y) { // a[x] - a[y]
    find(x), find(y);
    if (pa[x] != pa[y]) return -1;
    return (dist[y] - dist[x] + M) % M;
  }
};

struct fenwick{ // 二维树状数组
  void add(int x, int y, int v) {
    for (int i = x; i <= n; i += lowbit(i))
      for (int j = y; j <= m; j += lowbit(j)) c[i][j] += v;
  }
};

def count_up_to(x, k):
    """计算 [0, x] 中二进制第 k 位为 1 的整数个数"""
    if x < 0:
        return 0
    T = 1 << (k + 1)      # 周期长度 2^(k+1)
    L = 1 << k            # 每个周期中 1 的数量 2^k
    full_cycles = (x + 1) // T
    remainder = (x + 1) % T
    return full_cycles * L + max(0, remainder - L)

def query_range(l, r, k):
    """查询 [l, r] 中二进制第 k 位为 1 的整数个数"""
    return count_up_to(r, k) - count_up_to(l - 1, k)

int getPos(array<int, 2> p) {
    auto [x, y] = p;
    if (x == 0 && y == 0) return -1;       // 原点
    if (x >= 0 && y > 0) return 1;          // 第一象限
    if (x > 0 && y <= 0) return 2;          // 第二象限
    if (x <= 0 && y < 0) return 3;          // 第三象限
    if (x < 0 && y >= 0) return 4;          // 第四象限
    assert(false);
    return 0;
}

sort(a + 1, a + 1 + n, [](array<int, 2>& A, array<int, 2>& B){
    int pA = getPos(A);
    int pB = getPos(B);

    if (pA != pB) return pA < pB;  // 先按照象限排序

    ll res = 1ll * A[0] * B[1] - 1ll * B[0] * A[1];
    return res < 0;  // 判断同象限点的顺逆时针
});

for (auto i : views::iota(1, n + 1)) {}

auto p = std::ranges::partition_point(v, odd);
std::cout << *p << '\n';

std::map<int, std::string> mp = {{1, "a"}, {2, "b"}, {3, "c"}}; // 反向迭代map
for (auto&& [k, v] : std::views::reverse(std::views::all(map))) { ... }
for (auto&& [k, v] : mp | rv::all | rv::reverse)
    std::cout << k << " " << v << "\n";

#include <algorithm>
bool next_permutation(iterator start, iterator end);

#define debug(x) cout << #x << "= " << x << endl

struct PairHash {
    size_t operator()(const std::pair<int,int>& p) const noexcept {
        return std::hash<long long>()(((long long)p.first << 32) ^ p.second);
    }
};
std::unordered_map<std::pair<int, int>, ll, PairHash> count;

#include <iostream>
#include <random>
using namespace std;
// 用随机设备作为种子
random_device rd;
mt19937 gen(rd());
// 直接使用gen() 返回一个unsigned int类型的数
// 所以你需要使用 int x = gen() >> 1; 来截断

// 或者用固定种子
mt19937 gen2(42);
uniform_int_distribution<int> dist(1, 6); // [1,6] 区间
cout << dist(gen) << endl;  // 模拟掷骰子

template<typename T>
void clear(T& v){ T().swap(v); }

你是 ACM 算法竞赛 Markdown 笔记整理助手。
我会输入一些零碎、口语化、不成体系的知识点。

请你将它们整理为简短、清晰、易理解的总结，要求：
1. 控制在几句话内
2. 偏向比赛时快速翻笔记能看懂
3. 使用算法竞赛常用表述
4. 适合直接写进 Markdown 笔记

输出要求：
- 不讲背景、不写推导
- 不废话，只保留结论和用法
- 表述尽量精炼、好记

你是 ACM 算法竞赛 Markdown 笔记的结构维护助手。

下面是我当前笔记的【完整多层目录结构】，
请你严格基于该目录来判断我新增内容的插入位置。

【目录结构】
（粘贴当前 md 的完整多层目录，包括一级 / 二级 / 三级）

【我新增的内容】
（粘贴新的算法、结论、模板或技巧）

请你按以下格式输出，并且【每一层都要写全】：

1️⃣ 推荐插入路径（从一级到最深层）：
- 一级标题：
- 二级标题：
- 三级标题（若无则写“无”）：
- 四级标题（若无则写“无”）：

2️⃣ 是否需要新建标题：
- 新建层级：（二级 / 三级 / 四级 / 不需要）
- 原因说明：

3️⃣ 若存在多个可选位置：
- 给出所有候选路径
- 指出最推荐的一条，并说明理由

4️⃣ 若内容与现有笔记有重叠：
- 指出应合并的具体小节
- 或说明为何应独立成新小节