diff --git a/book/06-github/sections/3-maintaining.asc b/book/06-github/sections/3-maintaining.asc
index e8b851376..16a233541 100644
--- a/book/06-github/sections/3-maintaining.asc
+++ b/book/06-github/sections/3-maintaining.asc
@@ -1,134 +1,133 @@
 [[_maintaining_gh_project]]
-=== Maintaining a Project
+=== Pagpapanatili ng isang Proyekto
 
-Now that we're comfortable contributing to a project, let's look at the other side: creating, maintaining and administering your own project.
+Ngayon na kumportable tayong nag-aambag sa isang proyekto, tingnan natin ang kabilang panig: paglikha, pagpapanatili at pangangasiwa ng iyong sariling proyekto.
 
-==== Creating a New Repository
+==== Paglilikha ng isang Bagong Repositoryo
 
-Let's create a new repository to share our project code with.
-Start by clicking the ``New repository'' button on the right-hand side of the dashboard, or from the `+` button in the top toolbar next to your username as seen in <<_new_repo_dropdown>>.
+Lumikha ng isang bagong repositoryo upang maibahagi ang ating code ng proyekto.
+Simulan sa pamamagitan ng pag-click sa pindutan na ``Bagong Repositoryo'' sa kanang bahagi ng dashboard, o mula sa pindutan na `+` sa itaas na toolbar kasunod sa iyong usernmame gaya ng nakikita sa <<_new_repo_dropdown>>.
 
-.The ``Your repositories'' area.
+.Ang lawak na ``Iyong mga repositoryo''.
 image::images/newrepo.png[The ``Your repositories'' area.]
 
 [[_new_repo_dropdown]]
-.The ``New repository'' dropdown.
-image::images/new-repo.png[The ``new repository'' dropdown.]
+.Ang dropdown na ``Bagong repositoryo''.
+image::images/new-repo.png[The ``new repositoryo'' dropdown.]
 
-This takes you to the ``new repository'' form:
+Ito ay nagdadala sa iyo sa form ng ``bagong repositoryo'':
 
-.The ``new repository'' form.
-image::images/newrepoform.png[The ``new repository'' form.]
+.Ang form ng ``bagong repositoryo''.
+image::images/newrepoform.png[Ang form ng ``bagong repositoryo''.]
 
-All you really have to do here is provide a project name; the rest of the fields are completely optional.
-For now, just click the ``Create Repository'' button, and boom – you have a new repository on GitHub, named `<user>/<project_name>`.
+Ang kailangan mo lang gawin dito ay magbigay ng isang pangalan ng proyekto; ang lahat ng mga patlang ay ganap na opsyonal.
+Sa ngayon, i-click lamang ang pindutan na ``Lumikha ng Repositoryo'' - mayroon kang isang bagong repositoryo sa GitHub, pinangalanang `<user>/<project_name>`.
 
-Since you have no code there yet, GitHub will show you instructions for how to create a brand-new Git repository, or connect an existing Git project.
-We won't belabor this here; if you need a refresher, check out <<_git_basics_chapter#_git_basics_chapter>>.
+Dahil wala kang code doon, ipapakita sa iyo ng GitHub ang mga tagubilin kung paano lumikha ng isang bagong tatak ng repositoryo ng Git, o ikonekta ang isang umiiral na proyekto ng Git.
+Hindi namin balabaan ito dito; kung kailangan mo ng refresher, i-check out ang <<_git_basics_chapter#_git_basics_chapter>>.
 
-Now that your project is hosted on GitHub, you can give the URL to anyone you want to share your project with.
-Every project on GitHub is accessible over HTTPS as `https://github.com/<user>/<project_name>`, and over SSH as `git@github.com:<user>/<project_name>`.
-Git can fetch from and push to both of these URLs, but they are access-controlled based on the credentials of the user connecting to them.
+Ngayon na naka-host na ang iyong proyekto sa GitHub, maaari kang magbigay ng URL sa sinuman na gusto mong bahagian ng iyong proyekto.
+Bawat proyekto sa GitHub ay maaaring i-access sa HTTPS bilang `https://github.com/<user>/<project_name>`, at sa SSH bilang `git@github.com:<user>/<project_name>`.
+Maaaring mag-fetch ang Git mula sa at mag-push sa parehong mga URL na ito, ngunit sila ay kontrolado ng access batay sa mga kredensyal ng gumagamit na kumukonekto dito.
 
-[NOTE]
+[TANDAAN]
 ====
-It is often preferable to share the HTTPS based URL for a public project, since the user does not have to have a GitHub account to access it for cloning.
-Users will have to have an account and an uploaded SSH key to access your project if you give them the SSH URL.
-The HTTPS one is also exactly the same URL they would paste into a browser to view the project there.
+Madalas na lalong kanais-nais na ibahagi ang URL na nakabatay sa HTTPS para sa isang pampublikong proyekto, dahil ang gumagamit ay hindi kailangang magkaroon ng isang account sa GitHub upang ma-access ito para sa pag-clone.
+Ang mga gumagamit ay magkakaroon ng isang account at isang na-upload na SSH key upang ma-access ang iyong proyekto kung binibigyan mo sila ng SSH URL.
+Ang HTTPS ay isa ring eksaktong parehong URL na kanilang idikit sa isang browser upang tingnan ang proyekto doon.
 ====
 
-==== Adding Collaborators
+==== Pagdaragdag ng mga Tagapangasiwa
 
-If you're working with other people who you want to give commit access to, you need to add them as ``collaborators''.
-If Ben, Jeff, and Louise all sign up for accounts on GitHub, and you want to give them push access to your repository, you can add them to your project.
-Doing so will give them ``push'' access, which means they have both read and write access to the project and Git repository.
+Kung ikaw ay nagtatrabaho kasama ang ibang tao na nais mong bigyan ng access sa pag-commit, kailangan mong idagdag sila bilang ``tagapangasiwa''.
+Kung si Ben, Jeff, and Louise ay nag-sign up ng mga account sa GitHub, at gusto mo silang bigyan ng access sa pag-push sa iyong repositoryo, maaari mo silang idagdag sa iyong proyekto.
+Ang paggawa nito ay nagbibigay sa kanila ng access sa ``push'', na nangangahulugan na mayroon silang access sa pagbasa at pagsulat sa proyekto at repositoryo ng Git.
 
-Click the ``Settings'' link at the bottom of the right-hand sidebar.
+I-click ang link ng ``Settings'' sa ibaba ng kanang sidebar.
 
-.The repository settings link.
-image::images/reposettingslink.png[The repository settings link.]
+.Ang link ng settings ng repositoryo.
+image::images/reposettingslink.png[Ang link ng settings ng repositoryo.]
 
-Then select ``Collaborators'' from the menu on the left-hand side.
-Then, just type a username into the box, and click ``Add collaborator.''
-You can repeat this as many times as you like to grant access to everyone you like.
-If you need to revoke access, just click the ``X'' on the right-hand side of their row.
+Pagkatapos piliin ang =``Tagapangasiwa'' mula sa menu sa kaliwang bahagi.
+Pagkatapos, magtipa ng username sa kahon, at i-click ang ``Magdagdag ng tagapangasiwa.''
+Maaari mong ulitin ito nang maraming beses hangga't gusto mo upang magbigay ng access sa lahat ng iyong gusto
+Kung kailangan mong bawiin ang access, i-click lamang ang `` X '' sa kanang bahagi ng kanilang hilera.
 
-.Repository collaborators.
-image::images/collaborators.png[The repository collaborators box.]
+.Tagapangasiwa ng Repositoryo.
+image::images/tagapangasiwa.png[Ang kahon ng tagapangasiwa ng repositoryo.]
 
-==== Managing Pull Requests
+==== Pamamahala ng mga Kahilingan na Pull
 
-Now that you have a project with some code in it and maybe even a few collaborators who also have push access, let's go over what to do when you get a Pull Request yourself.
+Ngayon na mayroon kang isang proyekto na may ilang mga code at marahil kahit na ilang mga tagapangasiwa na mayroon ding access sa push, talakayin natin kung ano ang gagawin kapag kumuha ka ng isang Kahilingan na Pull sa iyong sarili.
 
-Pull Requests can either come from a branch in a fork of your repository or they can come from another branch in the same repository.
-The only difference is that the ones in a fork are often from people where you can't push to their branch and they can't push to yours, whereas with internal Pull Requests generally both parties can access the branch.
+Ang Kahilingan na Pull ay maaaring mula sa isang branch sa isang fork ng iyong repositoryo o sila ay maaari mula sa ibang branch sa parehong repositoryo.
+Ang tanging kaibahan ay ang mga nasa isang fork ay madalas mula sa mga tao kung saan hindi ka maaaring mag-push sa kanilang branch at hindi nila maaaring mag-push sa iyo, samantalang ang panloob na Kahilingan na Pull ay maaaring ma-access ng parehong partido sa branch.
 
-For these examples, let's assume you are ``tonychacon'' and you've created a new Arduino code project named ``fade''.
+Para sa mga halimbawang ito, ating ipalagay na ikaw ay ``tonychacon'' at naglikha ka ng isang bagong proyekto na Arduino code na pinangalanang ``fade''.
 
 [[_email_notifications]]
-===== Email Notifications
+===== Mga Abiso sa Email
 
-Someone comes along and makes a change to your code and sends you a Pull Request.
-You should get an email notifying you about the new Pull Request and it should look something like <<_email_pr>>.
+May nagsasama at gumagawa ng pagbabago sa iyong code at nagpapadala sa iyo ng Kahilingan na Pull.
+Dapat kang makakuha ng email na nag-aabiso sa iyo tungkol sa bagong Kahilingan na Pull at dapat itong magmukhang tulad ng <<_email_pr>>.
 
 [[_email_pr]]
-.Email notification of a new Pull Request.
+.Abiso sa email ng isang bagong Kahilingan na Pull.
 image::images/maint-01-email.png[Pull Request email notification]
 
-There are a few things to notice about this email.
-It will give you a small diffstat -- a list of files that have changed in the Pull Request and by how much.
-It gives you a link to the Pull Request on GitHub.
-It also gives you a few URLs that you can use from the command line.
+Mayroong ilang mga bagay na napapansin tungkol sa email na ito.
+Ito ay magbibigay sa iyo ng isang maliit na diffstat - isang listahan ng mga file na nagbago sa Kahilingan na Pull at kung gaano.
+Nagbibigay ito sa iyo ng isang link sa Kahilingan na Pull sa GitHub.
+Nagbibigay din ito sa iyo ng ilang mga URL na maaari mong gamitin mula sa command line.
 
-If you notice the line that says `git pull <url> patch-1`, this is a simple way to merge in a remote branch without having to add a remote.
-We went over this quickly in <<_distributed_git#_checking_out_remotes>>.
-If you wish, you can create and switch to a topic branch and then run this command to merge in the Pull Request changes.
+Kung mapapansin mo ang linya na nagsasabing `git pull <url> patch-1`, ito ay isang simpleng paraan upang pagsamahin sa isang remote branch nang hindi na kinakailangang magdagdag ng isang remote.
+Tinalakay natin ito nang mabilis sa <<_distributed_git#_checking_out_remotes>>.
+Kung naisin mo, maaari kang lumikha at lumipat sa isang branch ng paksa at pagkatapos ay patakbuhin ang utos na ito upang magsama sa mga pagbabago sa Kahilingan na Pull.
 
-The other interesting URLs are the `.diff` and `.patch` URLs, which as you may guess, provide unified diff and patch versions of the Pull Request.
-You could technically merge in the Pull Request work with something like this:
+Ang iba pang mga kagiliw-giliw na mga URL ay ang mga URL na `.diff` at` .patch`, na kung saan ay maaari mong hulaan, magbigay ng pinag-isang diff at patch na bersyon ng Kahilingan na Pull.
+Maaari mong pagsamahin sa trabaho ng Kahilingan na Pull sa isang bagay na tulad nito:
 
 [source,console]
 ----
 $ curl http://github.com/tonychacon/fade/pull/1.patch | git am
 ----
 
-===== Collaborating on the Pull Request
+===== Pangangasiwa sa Kahilingan na Pull
 
-As we covered in <<_github#_github_flow>>, you can now have a conversation with the person who opened the Pull Request.
-You can comment on specific lines of code, comment on whole commits or comment on the entire Pull Request itself, using GitHub Flavored Markdown everywhere.
+Sa natalakay sa <<_github#_github_flow>>, maaari ka na ngayong magkaroon ng pag-uusap sa taong nagbukas ng Kahilingan na Pull.
+Maaari kang magkomento sa mga tiyak na linya ng code, magkomento sa buong commit o magkomento sa buong Kahilingan na Pull mismo, gamit ang GitHub Flavored Markdown saanman.
 
-Every time someone else comments on the Pull Request you will continue to get email notifications so you know there is activity happening.
-They will each have a link to the Pull Request where the activity is happening and you can also directly respond to the email to comment on the Pull Request thread.
+Sa tuwing may ibang komento sa Kahilingan na Pull patuloy kang makakakuha ng mga abiso sa email upang malaman mo na may nangyayaring aktibidad.
+Ang bawat isa ay may isang link sa Kahilingan na Pull kung saan ang aktibidad ay nangyayari at maaari mo ring direktang tumugon sa email upang magkomento sa thread ng Kahilingan na Pull.
 
-.Responses to emails are included in the thread.
+.Kasama sa thread ang mga tugon sa mga email.
 image::images/maint-03-email-resp.png[Email response]
 
-Once the code is in a place you like and want to merge it in, you can either pull the code down and merge it locally, either with the `git pull <url> <branch>` syntax we saw earlier, or by adding the fork as a remote and fetching and merging.
+Sa sandaling ang code ay nasa isang lugar na gusto mo at nais na pagsamahin ito, maaari mong i-pull ang code pababa at pagsamahin ito nang lokal, alinman sa `git pull <url> <branch>` syntax na nakita natin kanina, o sa pamamagitan ng pagdaragdag ng fork bilang isang remote at pagkuha at pagsasama.
 
-If the merge is trivial, you can also just hit the ``Merge'' button on the GitHub site.
-This will do a ``non-fast-forward'' merge, creating a merge commit even if a fast-forward merge was possible.
-This means that no matter what, every time you hit the merge button, a merge commit is created.
-As you can see in <<_merge_button>>, GitHub gives you all of this information if you click the hint link.
+Kung ang pagsama-sama ay walang halaga, maaari mo ring pindutin ang pindutan na ``Merge'' sa site ng GitHub.
+Ito ay gagawa ng isang pagsama-sama na ``non-fast-forward'', na naglilikha ng isang merge commit kahit na ang merge na naka-fast-forward ay posible.
+Nangangahulugan ito na kung anuman, sa bawat oras na pindutin mo ang pindutan ng merge, isang merge commit ay nilikha.
+Sa makikita mo sa <<_merge_button>>, binibigay sa iyo ng GitHub ang lahat na impormasyong ito kung i-click mo ang link ng implikasyon.
 
 [[_merge_button]]
-.Merge button and instructions for merging a Pull Request manually.
+.Pindutan na merge at mga tagubilin sa manu-manong pagsama-sama ng isang Kahilingan na Pull.
 image::images/maint-02-merge.png[Merge button]
 
-If you decide you don't want to merge it, you can also just close the Pull Request and the person who opened it will be notified.
+Kung nagpasya kang hindi mo nais na pagsamahin ito, maaari mo ring isara ang Kahilingan na Pull at aabisuhan ang taong nagbukas nito.
 
 [[_pr_refs]]
-===== Pull Request Refs
+===== Refs ng Kahilingan na Pull
 
-If you're dealing with a *lot* of Pull Requests and don't want to add a bunch of remotes or do one time pulls every time, there is a neat trick that GitHub allows you to do.
-This is a bit of an advanced trick and we'll go over the details of this a bit more in <<_git_internals#_refspec>>, but it can be pretty useful.
+Kung ikaw ay nakikitungo sa isang *maraming* mga Kahilingan na Pull at hindi nais na magdagdag ng isang bungkos ng mga remote o gumawa ng isang beses na mga pull sa bawat oras, may isang malinis na trick na pinapahintulutan ng GitHub na gawin mo.
+Ito ay isang konting advanced na trick at tatalakayin natin ang mga detalye nito sa <<_git_internals#_refspec>>, ngunit ito ay maaaring kapaki-pakinabang.
 
-GitHub actually advertises the Pull Request branches for a repository as sort of pseudo-branches on the server.
-By default you don't get them when you clone, but they are there in an obscured way and you can access them pretty easily.
+Ang GitHub ay tunay na nag-aanunsiyo ng mga branch ng Kahilingan na Pull para sa isang repositoryo bilang uri ng mga pseudo-branch sa server. Bilang default hindi mo makuha ang mga ito kapag ikaw ay nag-clone, ngunit doon sila sa isang nakakubling paraan at maaari mong madaling ma-access ang mga ito.
 
-To demonstrate this, we're going to use a low-level command (often referred to as a ``plumbing'' command, which we'll read about more in <<_git_internals#_plumbing_porcelain>>) called `ls-remote`.
-This command is generally not used in day-to-day Git operations but it's useful to show us what references are present on the server.
+Upang ipakita ito, gagamitin namin ang isang mababang antas na utos (madalas na tinutukoy bilang isang utos na ``plumbing'', kung saan babasahin natin ang tungkol dito nang higit pa sa <<_git_internals#_plumbing_porcelain>>) na tinawag na `ls-remote`.
+Ang utos na ito ay karaniwang hindi ginagamit sa pang-araw-araw na pagpapatakbo ng Git ngunit ito ay kapaki-pakinabang upang ipakita sa atin kung anong mga reperensiya ang naroroon sa server.
 
-If we run this command against the ``blink'' repository we were using earlier, we will get a list of all the branches and tags and other references in the repository.
+Kung papatakbuhin natin ang utos na ito laban sa repositoryo na ``blink'' na ating ginamit natin kanina, makakakuha tayo ng listahan sa lahat ng mga branch at mga tag at ibang mga reperensiya sa repositoryo.
 
 [source,console]
 ----
@@ -143,16 +142,16 @@ a5a7751a33b7e86c5e9bb07b26001bb17d775d1a	refs/pull/4/head
 31a45fc257e8433c8d8804e3e848cf61c9d3166c	refs/pull/4/merge
 ----
 
-Of course, if you're in your repository and you run `git ls-remote origin` or whatever remote you want to check, it will show you something similar to this.
+Siyempre, kung ikaw ay nasa iyong repositoryo at nagpapatakbo ka ng `git ls-remote origin` o anumang remote na nais mong suriin, ipapakita nito sa iyo ang isang bagay na katulad nito.
 
-If the repository is on GitHub and you have any Pull Requests that have been opened, you'll get these references that are prefixed with `refs/pull/`.
-These are basically branches, but since they're not under `refs/heads/` you don't get them normally when you clone or fetch from the server -- the process of fetching ignores them normally.
+Kung ang repositoryo ay nasa GitHub at mayroon kang anumang mga Kahilingan na Pull na nabuksan, makakakuha ng mga reperensiyang ito na naka-prefix ng `refs/pull/`.
+Ang mga ito ay talagang mga branch, ngunit dahil ang mga ito ay wala sa ilalim ng `refs/heads/` hindi mo makuha ang mga ito nang normal kapag nag-clone ka o kumukuha mula sa server - ang proseso ng pagkuha ay hindi pinapansin ang mga ito nang normal.
 
-There are two references per Pull Request - the one that ends in `/head` points to exactly the same commit as the last commit in the Pull Request branch.
-So if someone opens a Pull Request in our repository and their branch is named `bug-fix` and it points to commit `a5a775`, then in *our* repository we will not have a `bug-fix` branch (since that's in their fork), but we _will_ have `pull/<pr#>/head` that points to `a5a775`.
-This means that we can pretty easily pull down every Pull Request branch in one go without having to add a bunch of remotes.
+Mayroong dalawang reperensiya sa bawat Kahilingan na Pull - ang isang na nagtatapos sa mga punto na `/head` sa estaktong parehong commit bilang huling commit sa branch ng Kahilingan na Pull.
+Kaya kung may isang nagbubukas ng Kahilingan na Pull sa ating repositoryo at ang kanilang branch ay pinangalanang `bug-fix` at ito ay nakaturo sa commit na `a5a775`, kung gayon sa *ating* repositoryo, wala tayong branch na `bug-fix` (dahil iyon ay nasa kanilang fork), nganit tayo ay  _magkakaroon_ ng `pull/<pr#>/head` na nakatuturo sa `a5a775`.
+Ito ay nangangahulugan na madali nating ma-pull ang bawat branch ng Kahilingan na Pull sa isang beses nang walang kinakailangang pagdagdag ng isang bungkos ng mga remote.
 
-Now, you could do something like fetching the reference directly.
+Ngayon, maaari mong gawin ang isang bagay tulad ng pagkuha ng direktang reperensiya.
 
 [source,console]
 ----
@@ -161,14 +160,14 @@ From https://github.com/libgit2/libgit2
  * branch            refs/pull/958/head -> FETCH_HEAD
 ----
 
-This tells Git, ``Connect to the `origin` remote, and download the ref named `refs/pull/958/head`.''
-Git happily obeys, and downloads everything you need to construct that ref, and puts a pointer to the commit you want under `.git/FETCH_HEAD`.
-You can follow that up with `git merge FETCH_HEAD` into a branch you want to test it in, but that merge commit message looks a bit weird.
-Also, if you're reviewing a *lot* of pull requests, this gets tedious.
+Ito ay nagsasabi sa Git, ``Kumonekta sa remote na `origin`, at i-download ang ref na pinangalanang `refs/pull/958/head`.''
+Masayang sinusunod ng Git, at nagda-download ng lahat na kinakailangan mo sa pagbuo ng ref na iyon, at naglalagay ng isang pointer sa commit na gusto mo sa ilalim ng `.git/FETCH_HEAD`.
+Maaari mong sundan iyon ng `git merge FETCH_HEAD` sa branch na gusto mong suriin, ngunit ang mensahe ng merge commit ay magiging mukhang kakaiba.
+Gayundin, kung sinusuri mo ang *maraming* mga kahilingan na pull, ito ay nakakapagod.
 
-There's also a way to fetch _all_ of the pull requests, and keep them up to date whenever you connect to the remote.
-Open up `.git/config` in your favorite editor, and look for the `origin` remote.
-It should look a bit like this:
+Mayroon ding paraan upang ma-fetch ang _lahat_ na mga kahilangan na pull, at nagsisigurado na ang mga ito ay laging bago sa tuwing ikaw ay kumukonekta sa remote.
+Buksan ang `.git/config` sa iyong paboritong editor, at hanapin ang remote na `origin`.
+Dapat magiging magmukhang ganito:
 
 [source,ini]
 ----
@@ -177,10 +176,10 @@ It should look a bit like this:
     fetch = +refs/heads/*:refs/remotes/origin/*
 ----
 
-That line that begins with `fetch =` is a ``refspec.''
-It's a way of mapping names on the remote with names in your local `.git` directory.
-This particular one tells Git, "the things on the remote that are under `refs/heads` should go in my local repository under `refs/remotes/origin`."
-You can modify this section to add another refspec:
+Ang linyang iyon na nagsisimula sa `fetch =` ay isang ``refspec.''
+Ito'y isang paraan ng pagmamapa ng mga pangalan sa remote sa mga pangalan sa iyong lokal na direktoryo na `.git`.
+Ang partikular na ito ay nagsasabi sa Git, "ang mga bagay sa remote na nasa ilalim ng `refs/heads` ay dapat mapunta sa aking lokal na repositoryo sa ilalim ng `refs/remotes/origin`."
+Maaari mong mabago ang seksiyon na ito upang magdagdag ng iba pang refspec:
 
 [source,ini]
 ----
@@ -190,8 +189,8 @@ You can modify this section to add another refspec:
     fetch = +refs/pull/*/head:refs/remotes/origin/pr/*
 ----
 
-That last line tells Git, ``All the refs that look like `refs/pull/123/head` should be stored locally like `refs/remotes/origin/pr/123`.''
-Now, if you save that file, and do a `git fetch`:
+Ang linyang iyon ay nagsasabi sa Git, ``Lahat ng mga ref na nagmumukhang `refs/pull/123/head` ay dapat nakaimbak nang lokal kagaya ng `refs/remotes/origin/pr/123`.''
+Ngayon, kung ikaw ay nag-save ng file na iyon, at gumawa ng isang `git fetch`:
 
 [source,console]
 ----
@@ -203,20 +202,20 @@ $ git fetch
 # …
 ----
 
-Now all of the remote pull requests are represented locally with refs that act much like tracking branches; they're read-only, and they update when you do a fetch.
-This makes it super easy to try the code from a pull request locally:
+Ngayon lahat ng mga kahilingan na pull na naka-remote ay kinakatawan nang lokal na may mga ref na kumilos tulad ng pagsubaybay sa mga branch; ang mga ito ay read-only, at ito ay na-update kapag gumawa ka ng isang fetch.
+Ginagawang napakadali nitong magsubok ng code mula sa isang kahilingan na pull ng pa-lokal:
 
 [source,console]
 ----
 $ git checkout pr/2
-Checking out files: 100% (3769/3769), done.
-Branch pr/2 set up to track remote branch pr/2 from origin.
-Switched to a new branch 'pr/2'
+Nag-check out ng mga file: 100% (3769/3769), tapos na.
+Branch pr/2 nag-set up upang sumaybay sa remote branch pr/2 mula sa origin.
+Pinalit sa isang bagong branch na 'pr/2'
 ----
 
-The eagle-eyed among you would note the `head` on the end of the remote portion of the refspec.
-There's also a `refs/pull/#/merge` ref on the GitHub side, which represents the commit that would result if you push the ``merge'' button on the site.
-This can allow you to test the merge before even hitting the button.
+Tatandaan ng nakamatang-agila sa inyo ang `head` sa huli ng remote na bahagi ng refspec.
+Mayroon ding ref na `refs/pull/#/merge` sa panig ng GitHub , na kumakatawan sa commit na magiging resulta kung i-push mo ang pindutan na ``merge'' sa site.
+Ito ay nagpapahintulot sa iyo na suriin ang merge bago pindutin ang pindutan.
 
 
 ===== Pull Requests on Pull Requests