import sys
import math

INF = 1e100

def solve(n, T, layers):
    # 将浮点阈值缩放为整数容量，避免精度误差
    S = 100
    W = int(round(T * S + 1e-9))

    dp = [INF] * (W + 1)
    dp[0] = 0.0

    for options in layers:
        ndp = [INF] * (W + 1)
        for j in range(W + 1):
            if dp[j] >= INF / 2:
                continue
            for loss, mem in options:
                w = int(round(loss * S + 1e-9))
                nj = j + w
                if nj <= W:
                    val = dp[j] + mem
                    if val < ndp[nj]:
                        ndp[nj] = val
        dp = ndp

    ans = min(dp)
    return ans

def main():
    data = sys.stdin.read().strip().split()
    if not data:
        return

    idx = 0
    n = int(data[idx]); idx += 1
    T = float(data[idx]); idx += 1

    layers = []
    for _ in range(n):
        k = int(data[idx]); idx += 1
        opts = []
        for _ in range(k):
            _bit = data[idx]; idx += 1  # 8bit/16bit 字符串，算法不需要用到
            loss = float(data[idx]); idx += 1
            mem = float(data[idx]); idx += 1
            opts.append((loss, mem))
        layers.append(opts)

    ans = solve(n, T, layers)
    print(f"{ans:.2f}")

if __name__ == "__main__":
    main()

#include <bits/stdc++.h>
using namespace std;

static const double INF = 1e100;

// 题目核心功能：多重选择背包，约束总loss<=T，最小化总mem
double solve(int n, double T, const vector<vector<pair<double,double>>>& layers) {
    int S = 100;
    int W = (int)llround(T * S + 1e-9);

    vector<double> dp(W + 1, INF);
    dp[0] = 0.0;

    for (const auto& options : layers) {
        vector<double> ndp(W + 1, INF);

        for (int j = 0; j <= W; j++) {
            if (dp[j] >= INF / 2) continue;

            for (auto &op : options) {
                double loss = op.first;
                double mem  = op.second;

                int w = (int)llround(loss * S + 1e-9);
                int nj = j + w;
                if (nj <= W) {
                    double val = dp[j] + mem;
                    if (val < ndp[nj]) ndp[nj] = val;
                }
            }
        }
        dp.swap(ndp);
    }

    double ans = INF;
    for (int j = 0; j <= W; j++) ans = min(ans, dp[j]);
    return ans;
}

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

    int n;
    double T;
    if (!(cin >> n >> T)) return 0;

    vector<vector<pair<double,double>>> layers;
    layers.reserve(n);

    for (int i = 0; i < n; i++) {
        int k;
        cin >> k;
        vector<pair<double,double>> opts;
        opts.reserve(k);

        for (int j = 0; j < k; j++) {
            string bit;    // 8bit/16bit 字符串，算法不使用
            double loss, mem;
            cin >> bit >> loss >> mem;
            opts.push_back({loss, mem});
        }
        layers.push_back(opts);
    }

    double ans = solve(n, T, layers);
    cout.setf(std::ios::fixed);
    cout << setprecision(2) << ans << "\n";
    return 0;
}

import java.io.*;
import java.util.*;

public class Main {
    static final double INF = 1e100;

    // 题目核心功能：多重选择背包，约束总loss<=T，最小化总mem
    static double solve(int n, double T, List<double[][]> layers) {
        int S = 100;
        int W = (int)Math.round(T * S + 1e-9);

        double[] dp = new double[W + 1];
        Arrays.fill(dp, INF);
        dp[0] = 0.0;

        for (double[][] options : layers) {
            double[] ndp = new double[W + 1];
            Arrays.fill(ndp, INF);

            for (int j = 0; j <= W; j++) {
                if (dp[j] >= INF / 2) continue;

                for (int t = 0; t < options.length; t++) {
                    double loss = options[t][0];
                    double mem = options[t][1];

                    int w = (int)Math.round(loss * S + 1e-9);
                    int nj = j + w;
                    if (nj <= W) {
                        double val = dp[j] + mem;
                        if (val < ndp[nj]) ndp[nj] = val;
                    }
                }
            }
            dp = ndp;
        }

        double ans = INF;
        for (int j = 0; j <= W; j++) ans = Math.min(ans, dp[j]);
        return ans;
    }

    public static void main(String[] args) throws Exception {
        // 输入规模不明确，使用 BufferedReader + StringTokenizer，简洁且足够稳定
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        List<String> tokens = new ArrayList<>();
        String line;
        while ((line = br.readLine()) != null) {
            line = line.trim();
            if (line.isEmpty()) continue;
            StringTokenizer st = new StringTokenizer(line);
            while (st.hasMoreTokens()) tokens.add(st.nextToken());
        }
        if (tokens.isEmpty()) return;

        int idx = 0;
        int n = Integer.parseInt(tokens.get(idx++));
        double T = Double.parseDouble(tokens.get(idx++));

        List<double[][]> layers = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int k = Integer.parseInt(tokens.get(idx++));
            double[][] opts = new double[k][2];
            for (int j = 0; j < k; j++) {
                idx++; // 8bit/16bit 字符串，算法不使用
                double loss = Double.parseDouble(tokens.get(idx++));
                double mem = Double.parseDouble(tokens.get(idx++));
                opts[j][0] = loss;
                opts[j][1] = mem;
            }
            layers.add(opts);
        }

        double ans = solve(n, T, layers);
        System.out.printf(Locale.US, "%.2f%n", ans);
    }
}