private final DisplayName displayName;
    // Null when the value has been calculated and assigned to the result field. When not null the result has not been calculated
    // or is currently being calculated or has just been calculated. It is possible for both this field and the result field to be
    // non-null at the same time for a brief period just after the result has been calculated
    @Nullable
    private volatile CalculationState<T, S> calculationState;

        cache = cacheFactory.newCache("parsedCSource", 40000, new FileContentCacheFactory.Calculator<IncludeDirectives>() {
            @Override
            public IncludeDirectives calculate(File file, boolean isRegularFile) {
                return parser.parseSource(file);
            }
        }, IncludeDirectivesSerializer.INSTANCE);
    }

    @Override

  void Compute(OpKernelContext* context) override {
    const Tensor& input_tensor = context->input(0);

    // Use the same input for the first output.
    context->set_output(0, input_tensor);

    // Calculate min/max statistics.
    const auto input_flat = input_tensor.flat<float>();
    Tensor *min_output = nullptr, *max_output = nullptr;
    OP_REQUIRES_OK(context, context->allocate_output("min", {}, &min_output));

// license that can be found in the LICENSE file.

package pprof

import "os"

// peBuildID returns a best effort unique ID for the named executable.
//
// It would be wasteful to calculate the hash of the whole file,
// instead use the binary name and the last modified time for the buildid.
func peBuildID(file string) string {
	s, err := os.Stat(file)
	if err != nil {
		return file
	}

        then:
        def ex = thrown(IllegalArgumentException)
        ex.message == "Unable to calculate percentage: 50 of -10. All inputs must be >= 0"

        when:
        percentOf(-1, 100) == 0
        then:
        ex = thrown(IllegalArgumentException)
        ex.message == "Unable to calculate percentage: -1 of 100. All inputs must be >= 0"
    }

 * properties files.
 */
public interface AllProperties {
    /**
     * Returns the system properties defined as command-line options.
     */
    Map<String, String> getRequestedSystemProperties();

    /**
     * Returns all properties that should be considered to calculate build option values.
     */

#endif  // SWIG

// TF_Bool is the C API typedef for unsigned char, while TF_BOOL is
// the datatype for boolean tensors.
#ifndef TF_Bool
#define TF_Bool unsigned char
#endif  // TF_Bool

// Macro used to calculate struct size for maintaining ABI stability across
// different struct implementations.
#ifndef TF_OFFSET_OF_END
#define TF_OFFSET_OF_END(TYPE, MEMBER) \
  (offsetof(TYPE, MEMBER) + sizeof(((TYPE *)0)->MEMBER))

	// Calculate signature.
	newSignature := getSignature(signingKey, stringToSign)

	return newSignature
}

// getTrailerChunkSignature - get trailer chunk signature.
func (cr *s3ChunkedReader) getTrailerChunkSignature() string {
	hashedChunk := hex.EncodeToString(cr.chunkSHA256Writer.Sum(nil))

	// Calculate string to sign.
	alg := signV4ChunkedAlgorithmTrailer + "\n"

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

class IntegerCalculations {
    def calculate() {
        int a = 9834
        int b = 238923
        int c = a + b
        int d = c - a
        int e = d * c
        int f = e.intdiv(5)
    }

	MOVL	CX, DX; \
	SHRL	$3, DX; \
	RORL	$18, CX; \
	ADDL	((index-7)*4)(BP), AX; \
	XORL	CX, BX; \
	XORL	DX, BX; \
	ADDL	((index-16)*4)(BP), BX; \
	ADDL	BX, AX; \
	MOVL	AX, ((index)*4)(BP)

// Calculate T1 in AX - uses AX, BX, CX and DX registers.
// Wt is passed in AX.
//   T1 = h + BIGSIGMA1(e) + Ch(e, f, g) + Kt + Wt
//     BIGSIGMA1(x) = ROTR(6,x) XOR ROTR(11,x) XOR ROTR(25,x)