<!DOCTYPE html>
<html lang="zh-Hant">
<head>
</head>
<body>
<div style="overflow: hidden; width: 300px; height: 300px;">
<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum volutpat consectetur enim a porttitor. Donec semper dignissim gravida. Suspendisse hendrerit faucibus sodales. Nulla at libero quis nisl pretium rhoncus. Nam id enim elementum, ultrices eros vehicula, eleifend lorem. Fusce blandit, lacus et blandit tristique, dui tellus rutrum sapien, et accumsan orci enim non ante. Vestibulum blandit nec nulla a mattis. Cras odio lorem, consectetur congue nulla sed, lacinia consectetur felis. Etiam quis dapibus quam, eget dignissim neque. Suspendisse blandit semper velit, a luctus risus. Sed placerat dolor vitae lacinia tempus. Donec sagittis metus eget euismod vulputate. Vivamus ultricies felis sed libero varius tempus vitae in est. Donec sodales leo at ornare dapibus. Etiam vel interdum neque, vel ullamcorper ante. Donec dictum tempor odio, efficitur pulvinar nibh efficitur sit amet.</p>
<div id="last" style="-webkit-writing-mode: vertical-rl;">
<p>Nam vel nisi non quam rutrum fermentum. Sed scelerisque magna eget dictum pretium. Phasellus ac hendrerit elit, id iaculis urna. Donec molestie lacus quis metus feugiat blandit. Cras in fermentum arcu. Phasellus enim lacus, placerat non arcu id, faucibus convallis turpis. Nullam eleifend eget arcu eget pretium. Donec pulvinar pellentesque leo.</p>
<p>Proin posuere tincidunt lorem id efficitur. Etiam sollicitudin ex lectus, id suscipit nunc blandit non. Duis pretium eget lectus non porta. Pellentesque mattis ex at urna elementum, sed sollicitudin nunc consectetur. Donec vehicula justo felis, nec malesuada orci cursus pellentesque. Nunc nec ligula nunc. Donec lorem nibh, posuere auctor ultrices quis, sollicitudin id erat. Donec consequat tellus arcu, mattis pharetra lectus euismod ut. Cras et enim in ex laoreet dignissim id ornare nisl. Phasellus ac placerat elit. In at placerat ligula. Nulla id nisl et diam faucibus euismod. Aenean libero ligula, viverra eu lacinia in, interdum eu erat. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce auctor, dolor et blandit rutrum, est orci egestas lorem, non lacinia ligula sapien quis enim. Quisque ornare, mi et commodo tincidunt, tellus ligula ultricies justo, ac sagittis augue dui ac nibh.</p>
</div>
<p>Vivamus justo felis, porttitor in metus at, dapibus iaculis mauris. Suspendisse hendrerit, metus at consectetur convallis, nisi nisl euismod ipsum, sed vulputate neque leo in ipsum. Maecenas vitae viverra felis, sed elementum purus. Curabitur hendrerit viverra tortor, sit amet elementum augue iaculis eget. Donec in lectus efficitur, congue urna et, ornare metus. Aliquam varius maximus dui vitae gravida. Pellentesque tortor tellus, blandit id nibh sit amet, egestas pellentesque nisl. Sed eget consectetur ipsum, sed rhoncus libero. Aenean efficitur justo facilisis nisi convallis vehicula. In volutpat sagittis mollis. Sed consequat tortor diam, eu vestibulum ipsum blandit sit amet. Pellentesque quis tincidunt sapien, at cursus metus. Suspendisse ut pulvinar augue, vitae efficitur metus. Pellentesque vitae vestibulum elit, sit amet maximus metus. Vivamus consectetur quis orci vitae elementum. Maecenas et euismod sapien.</p>
</div>
</div>
<script>
window.location = "#last";
</script>
</body>
</html>
