// use std::ops::{Index, IndexMut};
use std::cmp::{Ordering, min, max};
// use std::collections::{BinaryHeap, BTreeMap};
// use std::collections::btree_map::Entry::{Occupied, Vacant};
// use std::clone::Clone;

fn getline() -> String{
    let mut res = String::new();
    std::io::stdin().read_line(&mut res).ok();
    res
}

macro_rules! split {
    ($x: expr) => {
        ($x).trim().split(' ').collect()
    }
}

macro_rules! parse {
    ($x: expr) => {
        ($x).parse().unwrap()
    }
}

macro_rules! readl {
    ($t: ty) => {
        {
            let s = getline();
            let iv: Vec<_> = split!(s);
            let mut iter = iv.into_iter();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    };
    ($( $t: ty),+ ) => {
        {
            let s = getline();
            let iv: Vec<_> = split!(s);
            let mut iter = iv.into_iter();
            ($(iter.next().unwrap().parse::<$t>().unwrap(),)*)
        }
    };
}

macro_rules! rvec {
    ($x: expr) => {
        ($x).into_iter().map(|x| parse!(x)).collect()
    }
}

macro_rules! readlvec {
    ($t: ty) => {
        {
            let s = getline();
            let iv: Vec<_> = split!(s);
            iv.into_iter().map(|x| x.parse().unwrap()).collect::<Vec<$t>>()
        }
    }
}

macro_rules! debug {
    ($x: expr) => {
        println!("{}: {}", stringify!($x), $x)
    }
}

fn printvec<T>(v: &Vec<T>) where T: std::fmt::Display {
    for (i,e) in v.into_iter().enumerate() {
        if i != 0 {
            print!(" ");
        }
        print!("{}", e);
    }
    println!("");
}
fn main() {
    let n = readl!(usize);
    let mut v = Vec::with_capacity(n);
    let mut w = Vec::with_capacity(n);
    for _ in 0..n {
        let (x, y) = readl!(i32, i32);
        v.push(x);
        w.push(y);
    }
    let V = readl!(i32);
    let wsum: i32 = w.iter().sum();
    const INF: i32 = 1e9 as i32;
    
    let mut dp = vec![-INF; (wsum+1) as usize];
    dp[0] = 0;
    for i in 0..n {
        for j in (w[i] as usize..(wsum+1) as usize).rev() {
            dp[j] = max(dp[j], dp[j-w[i] as usize] + v[i]);
        }
    }
    let mut l = -1;
    let mut r = -1;
    let mut ma = 0;
    for j in 1..(wsum+1) as usize {
        ma = max(ma, dp[j]);
        if ma == V {
            if l == -1 {
                l = j as i32;
            }
            r = j as i32;
        }
    }
    println!("{} ", l);
    if r == wsum {
        println!("inf");
    } else {
        println!("{}", r);
    }
}