//Serene

#include<algorithm>

#include<iostream>

#include<cstring>

#include<cstdlib>

#include<cstdio>

#include<cmath>

using namespace std;

const int maxn=1000+10,maxm=3*5000+10,INF=0x3f3f3f3f;

int n,m,k,tu[maxn],S,T;

int aa,bb;char cc;

int read() {

    aa=0;cc=getchar();bb=1;

    while(cc<'0'||cc>'9') {

        if(cc=='-') bb=-1;

        cc=getchar();

    }

    while(cc>='0'&&cc<='9') aa=aa*10+cc-'0',cc=getchar();

    return aa*bb;

}

struct Node{

    int x,y,cap,flow,w;

    Node(){}

    Node(int x,int y,int cap,int w) :x(x),y(y),cap(cap),w(w){}

}node[2*maxm];

int cur[maxn],fir[maxn],nxt[2*maxm],e=1;

void add(int x,int y,int z,int w) {

    node[++e]=Node(x,y,z,w); nxt[e]=fir[x];fir[x]=e;

    node[++e]=Node(y,x,0,-w); nxt[e]=fir[y];fir[y]=e;

}

int zz[maxn],from[maxn],dis[maxn];bool vis[maxn];

bool spfa() {

    int s=1,t=0,x,y,z;

    memset(dis,0x3f3f3f3f,sizeof(dis));

    memset(zz,0,sizeof(zz));

    memset(vis,0,sizeof(vis));

    zz[++t]=S;vis[S]=1;dis[S]=0;

    while(s<=t) {

        x=zz[s%maxn];

        for(y=fir[x];y;y=nxt[y]) {

            z=node[y].y;

            if(dis[z]<=dis[x]+node[y].w||node[y].flow>=node[y].cap) continue;

            if(!vis[z]) {

                t++; zz[t%maxn]=z;

                vis[z]=1;

            }

            from[z]=y;

            dis[z]=dis[x]+node[y].w;

        }

        vis[x]=0;s++;

    }

    return dis[T]!=INF;

}

int MCMF() {

    int rs=0,now=k;

    while(spfa()&&k) {

        now=k;

        for(int i=T;i!=S;i=node[from[i]].x) now=min(now,node[from[i]].cap-node[from[i]].flow);

        now=min(now,k);k-=now;

        for(int i=T;i!=S;i=node[from[i]].x) {

            node[from[i]].flow+=now;

            node[from[i]^1].flow-=now;

            rs+=now*node[from[i]].w;

        }

    }

    return rs;

}

////////////////////////////////////

bool BFS() {

    int s=1,t=0,x,y,z;

    memset(dis,-1,sizeof(dis));

    dis[S]=0;zz[++t]=S;

    while(s<=t) {

        x=zz[s];s++;

        for(y=fir[x];y;y=nxt[y]) {

            z=node[y].y;

            if(dis[z]!=-1||node[y].flow>=node[y].cap) continue;

            zz[++t]=z; dis[z]=dis[x]+1;

        }

    }

    return dis[T]!=-1;

}

int DFS(int pos,int maxf) {

    if(pos==T||!maxf) return maxf;

    int rs=0,now,z;

    for(int &y=cur[pos];y;y=nxt[y]) {

        z=node[y].y;

        if(dis[z]!=dis[pos]+1||node[y].flow>=node[y].cap) continue;

        now=DFS(z,min(maxf,node[y].cap-node[y].flow));

        rs+=now;maxf-=now;

        node[y].flow+=now;

        node[y^1].flow-=now;

    }

    if(!rs) dis[pos]=-1;

    return rs;

}

int dinic() {

    int re=0;

    while(BFS()) {

        memcpy(cur,fir,sizeof(fir));

        re+=DFS(S,INF);

    }

    return re;

}

int ff[3*maxm],ff_tot=0;

int main() {

    n=read();m=read();k=read();

    int x,y,z,w;S=1;T=n;

    for(int i=1;i<=m;++i) {

        x=read();y=read();z=read();w=read();

        add(x,y,z,0);

        ff[3*ff_tot+1]=x;ff[3*ff_tot+2]=y;ff[3*(++ff_tot)]=w;

    }

    printf("%d ",dinic());

    for(int i=1;i<=ff_tot;++i) add(ff[i*3-2],ff[i*3-1],INF,ff[i*3]);

    printf("%d",MCMF());

    return 0;

}