diff --git a/_config.yml b/_config.yml
index 9945af8..a7632ae 100644
--- a/_config.yml
+++ b/_config.yml
@@ -22,3 +22,6 @@
 
   app:
     output: true
+
+  terms:
+    output: true
diff --git a/_devices/alcatelpopd3.markdown b/_devices/alcatelpopd3.markdown
index a716079..0abd841 100644
--- a/_devices/alcatelpopd3.markdown
+++ b/_devices/alcatelpopd3.markdown
@@ -1,11 +1,13 @@
+---
 layout: device
 title:  "Alcatel Pop D3"
-codename: DL750
-downloadfolder: DL750
+codename: dl750
+downloadfolder: dl750
 supportstatus: Current
-maintainer: kirito9
+maintainer: nashj1975
 oem: Alcatel
 devicetree: https://github.com/TeamWin/android_device_alcatel_dl750
+xdathread: http://forum.xda-developers.com/android/general/recovery-alcatel-pop-d3-t3522092
 ---
 
 {% include disclaimer.html %}
diff --git a/_devices/lgk7.markdown b/_devices/lgk7.markdown
new file mode 100644
index 0000000..6f15684
--- /dev/null
+++ b/_devices/lgk7.markdown
@@ -0,0 +1,24 @@
+---
+layout: device
+title:  "LG K7"
+codename: m1
+downloadfolder: m1
+supportstatus: Current
+maintainer: Czarsuperstar@gmail.com
+xdathread: http://forum.xda-developers.com/android/development/twrp-m1-lg-k7-t3462130
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_m1
+ddof: "/dev/block/bootdevice/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_includes/footer.html b/_includes/footer.html
index 132fa21..fd6ea3a 100644
--- a/_includes/footer.html
+++ b/_includes/footer.html
@@ -1,7 +1,7 @@
 <footer class="site-footer">
 
   <div class="wrapper">
-
+    <p class="text">&copy; 2014 to 2016 Team Win LLC.<br>Use of this site constitutes agreement to our <a href="https://twrp.me/terms/termsofservice.html">Terms of Service</a> and our <a href="https://twrp.me/terms/cookiepolicy.html">use of cookies</a></p>
     <div class="footer-col-wrapper">
 
       <div class="footer-col  footer-col-2">
diff --git a/_terms/cookiepolicy.markdown b/_terms/cookiepolicy.markdown
new file mode 100644
index 0000000..534d9ec
--- /dev/null
+++ b/_terms/cookiepolicy.markdown
@@ -0,0 +1,43 @@
+---
+layout: post
+title:  "Cookie Policy"
+date:   2016-12-20
+---
+
+<div class='page-heading'>What are cookies?</div>
+<hr />
+
+Cookies are small text files containing a string of characters that can be placed on your computer or mobile device that uniquely identify your browser or device.
+
+<div class='page-heading'>What are cookies used for?</div>
+<hr />
+
+Cookies allow a site or services to know if your computer or device has visited that site or service before. Cookies can then be used to help understand how the site or service is being used, help you navigate between pages efficiently, help remember your preferences, and generally improve your browsing experience. Cookies can also help ensure marketing you see online is more relevant to you and your interests.
+
+<div class='page-heading'>What types of cookies does Team Win use?</div>
+<hr />
+
+There are generally four categories of cookies: “Strictly Necessary,” “Performance,” “Functionality,” and “Targeting.” Team Win does not currently use any cookies, but third-party cookies may be used by our advertising partners or other third party partners. You can find out more about each cookie category below.
+
+1. Strictly Necessary Cookies. These cookies are essential, as they enable you to move around the Service and use its features, such as accessing logged in or secure areas.
+
+2. Performance Cookies. These cookies collect information about how you have used the Service, for example, information related to the unique username you have provided, so that less strain is placed on our backend infrastructure. These cookies may also be used to allow us to know that you have logged in so that we can serve you fresher content than a user who has never logged in. We also use cookies to track aggregate Service usage and experiment with new features and changes on the Service. The information collected is used to improve how the Service works.
+
+3. Functionality Cookies. These cookies allow us to remember how you’re logged in, whether you chose to no longer see advertisements, whether you made an edit to an article on the Service while logged out, when you logged in or out, the state or history of Service tools you’ve used. These cookies also allow us to tailor the Service to provide enhanced features and content for you and to remember how you’ve customized the Service in other ways, such as customizing the toolbars we offer in the right column of every page. The information these cookies collect may be anonymous, and they are not used to track your browsing activity on other sites or services.
+
+4. Targeting Cookies. Team Win, our advertising partners or other third party partners may use these types of cookies to deliver advertising that is relevant to your interests. These cookies can remember that your device has visited a site or service, and may also be able to track your device’s browsing activity on other sites or services other than Team Win. This information may be shared with organizations outside Team Win, such as advertisers and/or advertising networks to deliver the advertising, and to help measure the effectiveness of an advertising campaign, or other business partners for the purpose of providing aggregate Service usage statistics and aggregate Service testing.
+
+<div class='page-heading'>How long will cookies stay on my device?</div>
+<hr />
+
+The length of time a cookie will stay on your computer or mobile device depends on whether it is a “persistent” or “session” cookie. Session cookies will only stay on your device until you stop browsing. Persistent cookies stay on your computer or mobile device until they expire or are deleted.
+
+<div class='page-heading'>First and third party cookies</div>
+<hr />
+
+First-party cookies are cookies that belong to Team Win, third-party cookies are cookies that another party places on your device through our Service. Third-party cookies may be placed on your device by someone providing a service for Team Win, for example to help us understand how our service is being used. Third-party cookies may also be placed on your device by our business partners so that they can use them to advertise products and services to you elsewhere on the Internet.
+
+<div class='page-heading'>How to control and delete cookies</div>
+<hr />
+
+If you want to delete cookies follow the instructions at http://www.wikihow.com/Clear-Your-Browser%27s-Cookies. If you wish to disable your browser from receiving cookies follow the instructions at http://www.wikihow.com/Disable-Cookies. Note that if you set your browser to disable cookies, you may not be able to access certain parts of our Service and other parts of our Service may not work properly. You can find out more information cookie settings at third-party information sites, such as www.allaboutcookies.org.
diff --git a/_terms/termsofservice.markdown b/_terms/termsofservice.markdown
new file mode 100644
index 0000000..70ac1e2
--- /dev/null
+++ b/_terms/termsofservice.markdown
@@ -0,0 +1,40 @@
+---
+layout: post
+title:  "Terms of Service"
+date:   2016-12-20
+---
+
+This Agreement was last modified on December 20, 2016.
+
+Please read these Terms of Service completely using twrp.me which is owned and operated by Team Win LLC. This Agreement documents the legally binding terms and conditions attached to the use of the Site at twrp.me.
+
+By using or accessing the Site in any way, viewing or browsing the Site, or adding your own content to the Site, you are agreeing to be bound by these Terms of Service. You also agree to our [use of cookies](cookiepolicy.html).
+
+<div class='page-heading'>Intellectual Property</div>
+<hr />
+
+The Site and all of its original content are the sole property of Team Win LLC and are, as such, fully protected by the appropriate international copyright and other intellectual property rights laws.
+
+<div class='page-heading'>Termination</div>
+<hr />
+
+Team Win LLC reserves the right to terminate your access to the Site, without any advance notice.
+
+<div class='page-heading'>Links to Other Websites</div>
+<hr />
+
+Our Site does contain a number of links to other websites and online resources that are not owned or controlled by Team Win LLC.
+
+Team Win LLC has no control over, and therefore cannot assume responsibility for, the content or general practices of any of these third party sites and/or services. Therefore, we strongly advise you to read the entire terms and conditions and privacy policy of any site that you visit as a result of following a link that is posted on our site.
+
+<div class='page-heading'>Governing Law</div>
+<hr />
+
+This Agreement is governed in accordance with the laws of Missouri, United States.
+
+<div class='page-heading'>Changes to This Agreement</div>
+<hr />
+
+Team Win LLC reserves the right to modify these Terms of Service at any time. Your decision to continue to visit and make use of the Site after such changes have been made constitutes your formal acceptance of the new Terms of Service.
+
+Therefore, we ask that you check and review this Agreement for such changes on an occasional basis. Should you not agree to any provision of this Agreement or any changes we make to this Agreement, we ask and advise that you do not use or continue to access the Team Win LLC site immediately.
