Maximum Bitwise AND value in binary tree path from root to leaf nodes

// C program for
// Maximum Bitwise AND value in binary tree path from root to leaf nodes
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

 // Tree Node
struct TreeNode
{
	int data;
	struct TreeNode *left;
	struct TreeNode *right;
};
// Binary Tree
struct BinaryTree
{
	struct TreeNode *root;
};
// Create new tree
struct BinaryTree *newTree()
{
	// Create a dynamic tree 
	struct BinaryTree *tree = 
      (struct BinaryTree *) malloc(sizeof(struct BinaryTree));
	if (tree != NULL)
	{
		tree->root = NULL;
	}
	else
	{
		printf("Memory Overflow to Create tree Tree\n");
	}
	//return new tree
	return tree;
}
// This is creates and returns the new binary tree node
struct TreeNode *getNode(int data)
{
	// Create dynamic node
	struct TreeNode *node = 
      (struct TreeNode *) malloc(sizeof(struct TreeNode));
	if (node != NULL)
	{
		//Set data and pointer values
		node->data = data;
		node->left = NULL;
		node->right = NULL;
	}
	else
	{
		//This is indicates, segmentation fault or memory overflow problem
		printf("Memory Overflow\n");
	}
	//return new node
	return node;
}
//  Find maximum Bitwise AND in binary tree path using recursion
void maximumBitwiseAND(struct TreeNode *node, int value, int *result)
{
	if (node != NULL)
	{
		if ((node->left == NULL && node->right == NULL))
		{
			if ((value & node->data) > *result)
			{
				// Get new result
				*result = value & node->data;
			}
		}
		else if ((value & node->data) <= *result)
		{
			// Stop recursion When current path Bitwise And 
            // are less than result
			return;
		}
		else
		{
			// Visit left subtree
			maximumBitwiseAND(node->left, value & node->data, result);
			// Visit right subtree
			maximumBitwiseAND(node->right, value & node->data, result);
		}
	}
}
// Handles the request of finding maximum AND in binary Tree path  
void pathBitwiseAND(struct TreeNode *node)
{
	if (node == NULL)
	{
		// Empty tree
		return;
	}
	// Set initial minimum value
	int result = INT_MIN;
	// Find maximum And
	maximumBitwiseAND(node, node->data, & result);
	// Display calculated result  
	printf("\n Maximum Bitwise AND : %d", result);
}
int main(int argc, char
	const *argv[])
{
	struct BinaryTree *tree = newTree();
	/*
	        15                            
	       /   \    
	     -4     10    
	     / \      \               
	    6   12     6
	   /   / \    / 
	  4   6   8  2
	     /       
	    9          
	-----------------
	  Constructing binary tree
	*/
	tree->root = getNode(15);
	tree->root->left = getNode(-4);
	tree->root->left->right = getNode(12);
	tree->root->left->right->left = getNode(6);
	tree->root->left->right->left->left = getNode(9);
	tree->root->left->right->right = getNode(8);
	tree->root->left->left = getNode(6);
	tree->root->left->left->left = getNode(4);
	tree->root->right = getNode(10);
	tree->root->right->right = getNode(6);
	tree->root->right->right->left = getNode(2);
	/*
	    
	    (15 & -4 & 6 & 4 ) = 4
	    (15 & -4 & 12 & 6 & 9) = 0
	    (15 & -4 & 12 & 8) = 8
	    (15 & 10 & 6 & 2 ) = 2
	    
	    Result is : 8
	*/
	pathBitwiseAND(tree->root);
	return 0;
}

input

 Maximum Bitwise AND : 8