give resolution time in minutes for the given user story, only provide the number of minutes in the output without any other text

User story: The question of what makes a "good commit" arises occasionally. I feel that the following document:   https://wiki.openstack.org/wiki/GitCommitMessages#Structural_split_of_changes  presents a decent guideline. Pasting from it:  ================================ Structural split of changes ~~~~~~~~~~~~~~~~~~~~~~~~~~~ The cardinal rule for creating good commits is to ensure there is only one "logical change" per commit. There are many reasons why this is an important rule:  * The smaller the amount of code being changed, the quicker & easier it is to review & identify potential flaws.  * If a change is found to be flawed later, it may be necessary to revert the broken commit. This is much easier to do if there are not other unrelated code changes entangled with the original commit.  * When troubleshooting problems using GIT's bisect capability, small well defined changes will aid in isolating exactly where the code problem was introduced.  * When browsing history using GIT annotate/blame, small well defined changes also aid in isolating exactly where & why a piece of code came from.  Things to avoid when creating commits ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ With that in mind, there are some commonly encountered examples of bad things to avoid  * Mixing whitespace changes with functional code changes. The whitespace changes will obscure the important functional changes, making it harder for a reviewer to correctly determine whether the change is correct. Solution: Create 2 commits, one with the whitespace changes, one with the functional changes. Typically the whitespace change would be done first, but that need not be a hard rule.  * Mixing two unrelated functional changes. Again the reviewer will find it harder to identify flaws if two unrelated changes are mixed together. If it becomes necessary to later revert a broken commit, the two unrelated changes will need to be untangled, with further risk of bug creation.  * Sending large new features in a single giant commit. It may well be the case that the code for a new feature is only useful when all of it is present. This does not, however, imply that the entire feature should be provided in a single commit. New features often entail refactoring existing code. It is highly desirable that any refactoring is done in commits which are separate from those implementing the new feature. This helps reviewers and test suites validate that the refactoring has no unintentional functional changes. Even the newly written code can often be split up into multiple pieces that can be independently reviewed. For example, changes which add new internal APIs/classes, can be in self-contained commits. Again this leads to easier code review. It also allows other developers to cherry-pick small parts of the work, if the entire new feature is not immediately ready for merge. Addition of new public APIs or RPC interfaces should be done in commits separate from the actual internal implementation. This will encourage the author & reviewers to think about the generic API/RPC design, and not simply pick a design that is easier for their currently chosen internal implementation.  The basic rule to follow is:      If a code change can be split into a sequence of patches/commits,     then it should be split. Less is not more. More is more. ================================  In light of increasingly allowing/encouraging rebasing to happen, I think we should set an expectation of what the commits should look like. I'd motion the SAT to put this onto the agenda as an addition to our coding standards.
Answer: 32366.0