Question: ```
#include<stdio.h>
main()
{
  printf("%c\n",1-3+2["nexus"]);
}

```

The result is **v**. How does it turn out?  

What does the indentation (square ones) do?

Answer: 
I know this is a bit late for an answer but for anyone who navigates here this might help!

First thing is first: popBackStack()doesn't pop a fragment, it pops a fragment transaction. So the last fragment transaction is reversed upon being called. If you were displaying FragmentA currently and your transaction was:

```
fragmentTransaction.replace(R.id.your_layout, fragmentB);
fragmentTransaction.addToBackStack(null);
fragmentTransaction.commit();

```

It would replace FragmentA with FragmentB, and add that transaction (not the fragment) to the back stack. If you then hit the back button, it pops the transaction off the back stack, which was "replace this FragmentA with a FragmentB". Essentially, this instruction reverses the last transaction and removes it from the stack of transactions carried out. If the original FragmentA still exists, it uses that one. If it's been destroyed, it makes a new one.

So, if the Fragment hasn't been destroyed, then recalling the fragment after using on popBackStack(), the onStart() and onResume() methods are called. If the Fragment has been destroyed previously, then the lifecycle methods will be called starting from onAttach(). It's the same as pressing the back button on Activities.

Now the important bit, what happens re fragment lifecycle when we pop off back stack? Well as said before the fragment transaction is reversed so:

Scenario 1: Your fragmentB didn't already exist before transaction.
In this case the onCreate() and onAttach() methods are called during the transaction so the fragment will be destroyed and detached if you call popBackStack() and reverse the transaction (Note FragmentA probably already existed so replacing it wont destroy it as we're not undoing a fragment creation). In this case the lifecycle methods will be called starting from onAttach().

Scenario 2: Your fragmentB did already exist before transaction. In this case the fragment won't be destroyed and the next time you access it the onStart() and onResume() methods are called. 

[![Fragment Lifecycle](https://i.stack.imgur.com/d4eF5.png)](https://i.stack.imgur.com/d4eF5.png)

This fellow here explains a few things about using popbackstack() <http://vinsol.com/blog/2014/09/19/transaction-backstack-and-its-management/> and the fragment lifecycle <http://vinsol.com/blog/2014/10/22/fragment-view-state-retention-a-dirty-solution/>. The other related posts are worth reading too!
You can find a nice `Fragment` lifecycle diagram in the android docs [here](http://developer.android.com/guide/components/fragments.html). So yes, if the fragment is brought to the foreground from the backstack `onCreateView()`, `onActivityCreated()`, `onStart()` and `onResume()` are called.