#!/usr/bin/env python3

import sys
from math import sqrt

def main():
    # Read input
    line = sys.stdin.readline().strip().split()
    N, D = int(line[0]), int(line[1])

    # TODO: Read portfolio weights
    weights = list(map(float, sys.stdin.readline().strip().split()))

    # TODO: Read asset returns
    returns = []
    portfolio_returns = []

    for d in range(D):
        daily_returns = list(map(float, sys.stdin.readline().strip().split()))
        returns.append(daily_returns)

        # TODO: Compute weighted portfolio return for this day
        portfolio_return = 0.0
        for i in range(N):
            portfolio_return += weights[i] * daily_returns[i]
        portfolio_returns.append(portfolio_return)

    # TODO: Compute statistics on portfolio returns
    # Mean daily return
    mean_return = sum(portfolio_returns) / D

    # Variance (use two-pass or online algorithm)
    variance = sum((r - mean_return) ** 2 for r in portfolio_returns) / D

    # TODO: Compute portfolio volatility (annualized)
    # Formula: daily_vol = sqrt(variance)
    #          annual_vol = daily_vol * sqrt(252)
    daily_vol = sqrt(variance)
    portfolio_volatility = daily_vol * sqrt(252)

    # TODO: Compute portfolio Sharpe ratio (annualized, rf=0)
    # Formula: sharpe = (mean_return * 252) / annual_vol
    sharpe_ratio = (mean_return * 252) / portfolio_volatility if portfolio_volatility > 0 else 0.0

    # TODO: Compute VaR 95% and VaR 99%
    # Sort portfolio returns, find percentiles
    # Output as positive loss (negate the percentile value)
    sorted_returns = sorted(portfolio_returns)

    # 5th percentile for 95% VaR
    idx_95 = int(0.05 * D)
    if idx_95 >= D:
        idx_95 = D - 1
    var_95 = -sorted_returns[idx_95]

    # 1st percentile for 99% VaR
    idx_99 = int(0.01 * D)
    if idx_99 >= D:
        idx_99 = D - 1
    var_99 = -sorted_returns[idx_99]

    # TODO: Compute CVaR 95% and CVaR 99%
    # Average of all returns at or below VaR threshold
    cvar_95 = 0.0
    cvar_99 = 0.0

    # TODO: Compute maximum drawdown
    # Track cumulative return, running peak, and max drawdown
    max_drawdown = 0.0

    # TODO: Compute correlation matrix
    # First compute covariance matrix from returns
    # Then convert to correlation using standard deviations
    correlation = [[0.0] * N for _ in range(N)]

    # Output
    print(f"{portfolio_volatility:.6f}")
    print(f"{sharpe_ratio:.6f}")
    print(f"{var_95:.6f}")
    print(f"{var_99:.6f}")
    print(f"{cvar_95:.6f}")
    print(f"{cvar_99:.6f}")
    print(f"{max_drawdown:.6f}")

    # Output upper triangle of correlation matrix
    for i in range(N):
        row = []
        for j in range(i, N):
            row.append(f"{correlation[i][j]:.6f}")
        print(" ".join(row))

if __name__ == "__main__":
    main()