# This code is generated by [Atcoder_base64](https://github.com/kyomukyomupurin/AtCoder_base64)
# Original source code : 

"""
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

using namespace std;

using int64 = long long;

#define all($) begin($), end($)
#define rall($) rbegin($), rend($)

template <typename T>
class Modular {
 public:
  using Type = typename decay<decltype(T::value)>::type;

  constexpr Modular() : value() {}
  template <typename U>
  Modular(const U& x) {
    value = normalize(x);
  }

  template <typename U>
  static Type normalize(const U& x) {
    Type v;
    if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
    else v = static_cast<Type>(x % mod());
    if (v < 0) v += mod();
    return v;
  }

  const Type& operator()() const { return value; }
  template <typename U>
  explicit operator U() const { return static_cast<U>(value); }
  constexpr static Type mod() { return T::value; }

  Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; }
  Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; }
  template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); }
  template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); }
  Modular& operator++() { return *this += 1; }
  Modular& operator--() { return *this -= 1; }
  Modular operator++(int) { Modular result(*this); *this += 1; return result; }
  Modular operator--(int) { Modular result(*this); *this -= 1; return result; }
  Modular operator-() const { return Modular(-value); }

  template <typename U = T>
  typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type& operator*=(const Modular& rhs) {
  #ifdef _WIN32
    uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
    uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
    asm(
      "divl %4; \n\t"
      : "=a" (d), "=d" (m)
      : "d" (xh), "a" (xl), "r" (mod())
    );
    value = m;
  #else
    value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
  #endif
    return *this;
  }
  template <typename U = T>
  typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value, Modular>::type& operator*=(const Modular& rhs) {
    int64_t q = static_cast<int64_t>(static_cast<long double>(value) * rhs.value / mod());
    value = normalize(value * rhs.value - q * mod());
    return *this;
  }
  template <typename U = T>
  typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type& operator*=(const Modular& rhs) {
    value = normalize(value * rhs.value);
    return *this;
  }

  Modular& operator/=(const Modular& other) { return *this *= Modular(inverse(other.value, mod())); }

  template <typename U>
  friend const Modular<U>& abs(const Modular<U>& v) { return v; }

  template <typename U>
  friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);

  template <typename U>
  friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);

  template <typename U>
  friend std::istream& operator>>(std::istream& stream, Modular<U>& number);

 private:
  Type value;
};

template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value == rhs.value; }
template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs) { return lhs == Modular<T>(rhs); }
template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) == rhs; }

template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs) { return !(lhs == rhs); }

template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value < rhs.value; }

template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }

template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }

template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }

template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }

template<typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
  assert(b >= 0);
  Modular<T> x = a, res = 1;
  U p = b;
  while (p > 0) {
    if (p & 1) res *= x;
    x *= x;
    p >>= 1;
  }
  return res;
}

template <typename T>
bool IsZero(const Modular<T>& number) {
  return number() == 0;
}
 
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
  return stream << number();
}

template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
  typename common_type<typename Modular<T>::Type, int64_t>::type x;
  stream >> x;
  number.value = Modular<T>::normalize(x);
  return stream;
}

/*
using ModType = int;

struct VarMod { static ModType value; };
ModType VarMod::value;
ModType& MOD = VarMod::value;
using Mint = Modular<VarMod>;
*/

constexpr int MOD = (int) 1e9 + 7;
using Mint = Modular<std::integral_constant<std::decay<decltype(MOD)>::type, MOD>>;


int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);

  int n; cin >> n;
  // 10^n - 9^n - 9^n + 8^n
  Mint ans = power((Mint)10, n) - power((Mint)9, n) - power((Mint)9, n) + power((Mint)8, n);
  cout << ans << endl;

  return 0;
}

"""

import base64
import subprocess
import zlib


exe_bin = "c%1E9eQ*=U6<<mI#+C&!!9b`lu1W0#6bo!H5EILm;FK8S+Hy)h;E*L5UyvnNI)Tlk4Z(qlVw^Z_$}nx(A!(9HJ4s7sI-NFU8dFn9I-MzW(xfv<TH1zIrb**`5kiX9w|BdzyVYHjw)vxfcxU9d@3-&0{d&81yZ3yzw|#@vVnH<7(0YV9u0-Km2!3RlDgsy&Du%yH&{e1a_&kjqOD|gVv`DQ-(QC3QJWH=adTP<od}N-E+VvEAqUzzcZeOCH+m~=UdX&`5<?HpVL~n@b4H0=t5z(WR_Aih8`~+vI2kB`Zp`GWX5YCsDDLhNtk)Be$FM?hH`t->`Xcwu^Y+R0z_EJjc;rfW!yQ<;(NN9OPj3$Sc4>he?zN*2Qh&fltZE_IVjU7F*Jf3elRJgo?V7UBe-@5w`k5;{M_Y=RVp1ZwjOZ8tKZ|uaf<tRIEV9{y;&2nO+;&5qO;!q(qnUhY!Z=M0(0tTxM@H<W9dra`97Gr#+30`4>r%mi{H^HkA^-O)*Y+~PGBEQZA|A9%pcp~PaO4PzBS`Oj}Pap-~ezk&EQU?M5NJydJb=P5^ScL>($3QG9B&0xG5(Fgp{F{VOI3C_1CZurOzo{(}i-!Gy-bh#}GcLKUqg#w8yj`N4jYSe(oa>ev!qHH~7wnc?u3&#4E=ci!C?$MBueS@ZmA!$47!+a&DIN|C`22#uUhsCW5@gktK`|;@lbXa>LIBZlgD)yd9+!6)gS#3N!_lCyTa@~tBOx*7?KRSDQ#7Gf!B|ql0}-TS0NoGn6oUObg}#6o0U(e_gkeAk7aR%*0VzBrN`&bXqk)LH2YN1GGi3M%0?_1*?Y`DFVTH3n&8=`YD)}v2gq46Jyy9%|!+&kCcC7LWv>~NL;VkgC#G?2~J^U&}u?(-!0Kt-r#A2+o(?Z?ABCkohe@Jy-E5g=xlXALm(0!1bqtJc^pDtGDAcLPJ&z&Mpk5m41l|l<pc0a-C_ZqxJgP+ylb2NBbgO_UXX$@Yc!7plXy9TH00Y5g%H8@=l7<Xv!abl+sW%p8?4r_3m20x;~^ECKV8eIE4JgUL9&x4<6@Innfp}~tZ_zN1mScCH;Zx->R`Ohri5WjyyvSv>6BPWU`)$&Z^wNR8<x(xo7SG7P6^ZmGJ>TCwm(rV1(u1}qo`9+w=Q#myu^Ybu|hhXZc%$HyucYW%J%v&*!yF4{6^Ovp!9(Q$Wugt%TdED%&L76`feBU^2pS#EHcV&9Ip&zyUSfnN|#E<4Jt;Ib{d1@+M6X}~ki63ijtArk={=uKhU$Rgcigc%3a#u|S;HNw_6?nYTe}}GM&;ej-5?}`&uJlU;E(O?~Istg8j2|O-kvsKE#Y_=)*Yx9nd+O3q@%N#<W8;Ot`sTX*6XpCbJauO^+*pHc?7&Bj;S=}F6aZGfc{*K!Ta`MMeryKlXnRd%h+kPM_b6Egb5rY@xP7bp4)@l{^u&zZvwgT{FpUa7+WgLZ;K$})l1XDoE<I5+wGT@B#$9juQfIdDsXy~0Z%lXk+sE?PT5%7`CgqMaKMhiu`G-LF{qic04E+?C9)2wUS!{64MLu;-S_m$4=X}Lw%C=_C_BqR|?v)31>m>G)ED!p_N<-qZnYtO!=a0|W_|!CiJbfc?Imw@ykt)HUix@1$2F>j4ZGH&+1tqWNN1Fdw0l6OBo>J&`38<%EznsaWdFaB)d=ca<SbZ<ndvCH&?hh8<I@Jdf3hx;$@WM>o_YII4E&n<8<MMm=<Ay(f?!m|AxrD)#Ea$#3Vc~->O09hG0$={aclfabcoO;MvWFXY@46cI=EJx7vAh+0>RtZ$r5pL<7nksLr+IM#i`AV}#P?q)=chsaMSkoajrtXQ>IMG8zwyV<FX6@C$_i)PXD%l1Pfbt4)Vv^%W8)Lba6Us;?Q^5p&mQ?F^h6z<zH#@L+_(5rui$0TKDM-Dt~_<iZvoovPF?n;F0|L3lh^$5%eHjpV{n-LZ%Lf%RcfI<b*Vjd!IOI1ovC<@ADOi9YhF*D#}1@;oqL;Gm>kd6_}(PhL&&aypFeFvPp|mpq$mwLgM)*pms{V=)sywQDHcjb0`VLC>$$<$?r^*|7>gz(E(>3?j8mYVYwEb$@w1upbIlw)pVzJxqf&TBJP;9Ni9l4k0gz>!tDdCQ>(_BTAPneM+?K_*bv)SzJ<!#MfxZOv7|=I>zKJP}UoFgf1vpL!_!{v4mw>(x)B|`3JmsK8dB4TUvZo7Kh8&i~rG-V~mO=-{@tNi+uydVeUp1Bo`&9l?CL?cRcE<*L<xS;tb{FkMH!fOt?aG>Js*leS4rpf)WA_g10npwP7_dHP$IqiC_(|}a2D|cusMYQmv$onR58B%7+<`o|y>=wuWAC*7wZvWvh}&KX60P<k_Z)cJgXawVegt(nvCW(9j%{|OR@{bP<Mu**VWil75Zisg=CyNUd9C)^gZaF@{y+h5ZyG7wWN(Svo80z#sIS$|wbEMTXC{7UJ`HwEU-D<uY?@88X*SKK*)*GG(`=eevuQTXrvH;f@4xANH@)B1e$Uj>5|W{J()HvpPw%27Qm~Nl^uB#D;ptuTB0}l?I{l7H?*=}Y$;2={Ob*xd4tWc?WTtn=6QrEpsgIEM(Yy3YLgyoWqIcLs<Q|!x;U@^C_Z{>udI4>3p&sun(6^f-_0v0PTL0&eUhd<J(mxA<W(ZF^mLWWC*EHc@BLndf;k9?}pJh_NA2X?sbYK^u2M9ex=#zy0n9!4izO23U`7aXvzOu2cZ7o;Z)0>P+Np7{X(OJKIWm4u`Uv)J(>l^A6^wZe1!RR*`T;AYsQhr0+h9pBgPxVthp0E0+9xqV+SdSN~^Q*^;^dC!9yjb-=Jzk>vsUDxBu2(%?iaHJPGIZ7ux1(u8yj)%Xdfb8b8sc-+xB)#r4{b5TuTb|BJzk;iBYJ$kp&#4OmFl|J<FLv(BRu<ES&uKw!SM3WL+@l*T!}Yupd(})?j(2=;Wcho_g^Q$_sQ~=Xt<hF?c(&1iTy{2oz4<H{vCpkGx)OvKg-~!NWDW$y)Vo8+;P54>~M2*Fe<iS`P}(3Yk#dQKMy@^XG@IbSIG^_^&g*XCwJbvWce#{+8-o1+s<9Gom@XTD1UcefE<iJEU@8tg<Svnx*V5~^?$nTA2W%EIAaq3@s^C+Q9T*w69oSX!ge(4kxW>F)!6=BfX}rqQ1?@sQYP|`n&3xl7|&hr$4ulG+mv?FxGnl^;bjx~t+IUXe)TSCKRf<2R^#}O`8H*~*m>C|&toOpTdl{dZ3@oXciN2G*-iRIUx>m451PpDu^Gp;93plGi5>dbc+zGZzjDmP{;MYT&zs<Rc_#5R%ttTbw%Z!z4_v-($+bG?!<A2L7qg$Oyk60}ntTHD`2}y+&D{+`*UdPr#kEEdI=j4n|E<D?o{l!ZZ*vC@x7pafxz*h+2#I8`;8OxfaD+;GlOTvOF)B(Z7?%=Kvain>MA^6;K^hQ(IQ}Mq1R)d?c0^*m(5jFWizkFYatH-u1A~#U6b?C8uUgY&EQF(2L?IB52Zn`kREiIyzIb3DEQFE+1H+)A;RM_iov0ve=yGrJ3f>M6?uW3kqet-a1mrzkNbua+;ojtHgEF0RNDs)7GwL{O-mszD>lgg))^;yg4Tl0!013X$a#&APNG8IePmcX*Y0*a8=mU008HvgfK9jlqA0nODriKzRp+5kYv@unzkR~>X>5e8)i7nAbIAu$*LI0*UI*&9uDyLyE5p=GE-b8}tjiansZ8=6Nm`KVKpA8XX#Qt6AS=I!0S~Wn-u%c`*7CQ*Jp>C$(Yz9$h`pS?qF+3mzdVxxDh4#}NcBS|raz<lP*y(QdEtdj22)84eboM62NNBkjLNeDMNc1CTXgCV?6e`7)l3n3=LX1Uqi~wcva3p{QNp3JA;VNNdan`vb1{v@H_$!Z<Gai$dku%&+mUMq8p5+u(Wi=`qG!Hcd2E-s_WObNz<b-`?05$-ljq^WC_*{&)bh_W0#TnCNVffD@<t$3|**IQ~k!Oz`E=Hf8Zz!$#1bzHH{Q{gtsXjdiQCdrIdaPlO4IM~1tE=a4tDYVv9mdBTi$<TGt8YR2*j;+AqI85AFn0X5A?2)1_38PGQu;1N+s}kkqn$`OyQ{~%0zK{2uvV1Y|2;?<Q>stTbClBi1a|yr|L-OGt%RrNK1wGv?Z47M{{f_pVb0#?P)hGTXkzC-#pu&>B&Fkwyn~?+Gy3$rNhv#CMGXBmqfg(1Dcz?HRz&((N1VRP=+pOEN{bnJw*TKl`t?iS^C`Wbk>?oxSw`P1p5Cnf=NWx^ZdNJd@a%ZLh?ICyI!xL4dWC1liyi;pAtkPq>eKVp;1c8dSp7dCW$e}aIQ9P*2tYbk!06F-9Y#w3+55bqDuuuA6Y4+D=&R=hPG1kJPt!EPsJ?psAo?xL{Z9*{{{g9=y|AMCbqsEFFKZNk)I#)|$UcCdGftGd{);tj*QTK_kop;iWB1RwCi;((1KtdSv-<x6Msaii"

open("./kyomu", 'wb').write(zlib.decompress(base64.b85decode(exe_bin)))
subprocess.run(["chmod +x ./kyomu"], shell=True)
subprocess.run(["./kyomu"], shell=True)

Measured memory_bytes: 10728