#include <algorithm>
#include <bits/stdc++.h>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <iterator>
#include <type_traits>
#include <vector>

// lib/detail/ceil_and_floor.hpp
#ifndef DETAIL_CEIL_AND_FLOOR_HPP
#define DETAIL_CEIL_AND_FLOOR_HPP

namespace tools {
  template <typename T>
  constexpr T floor(T lhs, T rhs);

  template <typename T>
  constexpr T ceil(T lhs, T rhs);

  template <typename T>
  constexpr T floor(const T lhs, const T rhs) {
    return
      lhs >= 0 && rhs >= 0 ?
        lhs / rhs :
      lhs < 0 && rhs >= 0 ?
        -ceil<T>(-lhs, rhs) :
      lhs >= 0 && rhs < 0 ?
        -ceil<T>(lhs, -rhs) :
        floor<T>(-lhs, -rhs);
  }

  template <typename T>
  constexpr T ceil(const T lhs, const T rhs) {
    return
      lhs >= 0 && rhs >= 0 ?
        (lhs - 1 + rhs) / rhs :
      lhs < 0 && rhs >= 0 ?
        -floor<T>(-lhs, rhs) :
      lhs >= 0 && rhs < 0 ?
        -floor<T>(lhs, -rhs) :
        ceil<T>(-lhs, -rhs);
  }
}

#endif

// lib/floor_log2.hpp
#ifndef FLOOR_LOG2_HPP
#define FLOOR_LOG2_HPP


namespace tools {
  ::std::uint32_t floor_log2(::std::uint32_t x);
  ::std::uint64_t floor_log2(::std::uint64_t x);
  ::std::int32_t floor_log2(::std::int32_t x);
  ::std::int64_t floor_log2(::std::int64_t x);
}

#endif

// lib/bitcount.hpp
#ifndef BITCOUNT_HPP
#define BITCOUNT_HPP


namespace tools {
  ::std::uint32_t bitcount(::std::uint32_t x);
  ::std::uint64_t bitcount(::std::uint64_t x);
  ::std::int32_t bitcount(::std::int32_t x);
  ::std::int64_t bitcount(::std::int64_t x);
}

#endif

// lib/pow2.hpp
#ifndef POW2_HPP
#define POW2_HPP

/*
usage:

tools::pow2(5) => 32
*/


namespace tools {
  template <typename T, typename std::enable_if<std::is_unsigned<T>::value, std::nullptr_t>::type = nullptr>
  constexpr T pow2(const T x) {
    return static_cast<T>(1) << x;
  }

  template <typename T, typename std::enable_if<std::is_signed<T>::value, std::nullptr_t>::type = nullptr>
  constexpr T pow2(const T x) {
    return static_cast<T>(static_cast<typename std::make_unsigned<T>::type>(1) << static_cast<typename std::make_unsigned<T>::type>(x));
  }
}

#endif

// lib/util.hpp
#ifndef UTIL_HPP
#define UTIL_HPP


using i64 = ::std::int_fast64_t;
using u64 = ::std::uint_fast64_t;
using i32 = ::std::int_fast32_t;
using u32 = ::std::uint_fast32_t;

namespace tools {
  template <typename T>
  void read(::std::istream& is, ::std::vector<T>& vector, const typename ::std::vector<T>::size_type size) {
    vector.reserve(size);
    ::std::copy_n(::std::istream_iterator<T>(is), size, ::std::back_inserter(vector));
  }
  template <typename T>
  void read(::std::vector<T>& vector, const typename ::std::vector<T>::size_type size) {
    ::tools::read(::std::cin, vector, size);
  }

  template <typename T, ::std::size_t N>
  void read(::std::istream& is, ::std::array<T, N>& array) {
    ::std::copy_n(std::istream_iterator<T>(is), N, array.begin());
  }
  template <typename T, ::std::size_t N>
  void read(::std::array<T, N>& array) {
    ::tools::read(::std::cin, array);
  }
}

#endif

// lib/floor.hpp
#ifndef FLOOR_HPP
#define FLOOR_HPP


/*
usage:

tools::floor(5, 3) // => 1 (i.e., floor(5 / 3))
*/

#endif

// lib/floor_log2.cpp

namespace tools {
  ::std::uint32_t floor_log2(::std::uint32_t x) {
    x |= (x >> static_cast<::std::uint32_t>(1));
    x |= (x >> static_cast<::std::uint32_t>(2));
    x |= (x >> static_cast<::std::uint32_t>(4));
    x |= (x >> static_cast<::std::uint32_t>(8));
    x |= (x >> static_cast<::std::uint32_t>(16));
    return ::tools::bitcount(x) - static_cast<::std::uint32_t>(1);
  }

  ::std::uint64_t floor_log2(::std::uint64_t x) {
    x |= (x >> static_cast<::std::uint64_t>(1));
    x |= (x >> static_cast<::std::uint64_t>(2));
    x |= (x >> static_cast<::std::uint64_t>(4));
    x |= (x >> static_cast<::std::uint64_t>(8));
    x |= (x >> static_cast<::std::uint64_t>(16));
    x |= (x >> static_cast<::std::uint64_t>(32));
    return(::tools::bitcount(x) - static_cast<::std::uint64_t>(1));
  }

  ::std::int32_t floor_log2(::std::int32_t x) {
    return static_cast<::std::int32_t>(::tools::floor_log2(static_cast<::std::uint32_t>(x)));
  }

  ::std::int64_t floor_log2(::std::int64_t x) {
    return static_cast<::std::int64_t>(::tools::floor_log2(static_cast<::std::uint64_t>(x)));
  }
}

// lib/bitcount.cpp

namespace tools {
  ::std::uint32_t bitcount(::std::uint32_t x) {
    x = (x & static_cast<::std::uint32_t>(0x55555555ull)) + (x >> static_cast<::std::uint32_t>(1) & static_cast<::std::uint32_t>(0x55555555ull));
    x = (x & static_cast<::std::uint32_t>(0x33333333ull)) + (x >> static_cast<::std::uint32_t>(2) & static_cast<::std::uint32_t>(0x33333333ull));
    x = (x & static_cast<::std::uint32_t>(0x0f0f0f0full)) + (x >> static_cast<::std::uint32_t>(4) & static_cast<::std::uint32_t>(0x0f0f0f0full));
    x = (x & static_cast<::std::uint32_t>(0x00ff00ffull)) + (x >> static_cast<::std::uint32_t>(8) & static_cast<::std::uint32_t>(0x00ff00ffull));
    return (x & static_cast<::std::uint32_t>(0x0000ffffull)) + (x >> static_cast<::std::uint32_t>(16) & static_cast<::std::uint32_t>(0x0000ffffull));
  }

  ::std::uint64_t bitcount(::std::uint64_t x) {
    x = (x & static_cast<::std::uint64_t>(0x5555555555555555ull)) + (x >> static_cast<::std::uint64_t>(1) & static_cast<::std::uint64_t>(0x5555555555555555ull));
    x = (x & static_cast<::std::uint64_t>(0x3333333333333333ull)) + (x >> static_cast<::std::uint64_t>(2) & static_cast<::std::uint64_t>(0x3333333333333333ull));
    x = (x & static_cast<::std::uint64_t>(0x0f0f0f0f0f0f0f0full)) + (x >> static_cast<::std::uint64_t>(4) & static_cast<::std::uint64_t>(0x0f0f0f0f0f0f0f0full));
    x = (x & static_cast<::std::uint64_t>(0x00ff00ff00ff00ffull)) + (x >> static_cast<::std::uint64_t>(8) & static_cast<::std::uint64_t>(0x00ff00ff00ff00ffull));
    x = (x & static_cast<::std::uint64_t>(0x0000ffff0000ffffull)) + (x >> static_cast<::std::uint64_t>(16) & static_cast<::std::uint64_t>(0x0000ffff0000ffffull));
    return (x & static_cast<::std::uint64_t>(0x00000000ffffffffull)) + (x >> static_cast<::std::uint64_t>(32) & static_cast<::std::uint64_t>(0x00000000ffffffffull));
  }

  ::std::int32_t bitcount(::std::int32_t x) {
    return static_cast<::std::int32_t>(::tools::bitcount(static_cast<::std::uint32_t>(x)));
  }

  ::std::int64_t bitcount(::std::int64_t x) {
    return static_cast<::std::int64_t>(::tools::bitcount(static_cast<::std::uint64_t>(x)));
  }
}

// main.cpp

int main() {
  i64 A, B, C, K;
  std::cin >> A >> B >> C >> K;
  i64 required = A < B ? 0 : tools::floor_log2(tools::floor(A, B)) + 1;
  required += tools::pow2(required) * B < C ? 0 : tools::floor_log2(tools::floor(tools::pow2(required) * B, C)) + 1;
  std::cout << (required <= K ? "Yes" : "No") << '\n';
  return 0;
}

Measured memory_bytes: 3644