use std::io;

enum Num {
    One,
    Four,
    Five,
    Seven,
    Nine,
}

impl Num {
    fn value(&self) -> u32 {
        match *self {
            Num::One => 1,
            Num::Four => 4,
            Num::Five => 5,
            Num::Seven => 7,
            Num::Nine => 9,
        }
    }

    fn matches(&self) -> u32 {
        match *self {
            Num::One => 2,
            Num::Four => 4,
            Num::Five => 5,
            Num::Seven => 3,
            Num::Nine => 6,
        }
    }
}

fn max_num(n : u32) -> Num {
    match n {
        5 => Num::Five,
        4 => Num::Four,
        3 => Num::Seven,
        2 => Num::One,
        _ => Num::Nine,
    }
}

fn calc_digit(n : u32) -> u32 {
    n / Num::One.matches()
}

fn calc_result(r : &Vec<u32>) -> u64 {
    r.iter().rev().enumerate().fold(0, |s, (i, j)| s + 10i64.pow(i as u32) as u64 * (*j as u64))
}

fn main() {
    let mut input = String::new();

    io::stdin().read_line(&mut input).unwrap();

    let mut n : u32 = input.trim().parse().unwrap();

    let digits = calc_digit(n);

    let result : Vec<u32> = (1..digits+1).map(|_| Num::One.value()).collect();

    n = n - digits * Num::One.matches();

    let result = result.iter().map(|x| {
        if n != 0 {
            let match_num = n + Num::One.matches();
            let num = max_num(match_num);
            n = match_num - num.matches();
            num.value()
        } else {
            *x
        }
    }).collect();

    println!("{}", calc_result(&result));
}