text:
/*
    -- MAGMA (version 1.3.0) --
       Univ. of Tennessee, Knoxville
       Univ. of California, Berkeley
       Univ. of Colorado, Denver
       @date November 2014

       @precisions normal z -> s d c
*/

#ifndef MAGMABLAS_Z_H
#define MAGMABLAS_Z_H

#include "magma_types.h"

#define COMPLEX

#ifdef __cplusplus
extern "C" {
#endif

  /*
   * Interface to clean
   */

extern "C" magma_int_t
magma_zlarfbx_gpu(
    int m, int k, magmaDoubleComplex_ptr V, size_t v_offset, int ldv,
    magmaDoubleComplex_ptr dT, size_t dT_offset, int ldt, magmaDoubleComplex_ptr c, size_t c_offset,
    magmaDoubleComplex_ptr dwork, size_t dwork_offset,
    magma_queue_t queue);

extern "C" magma_int_t
magma_zlarfgtx_gpu(
    int n, magmaDoubleComplex_ptr dx0, size_t dx0_offset, magmaDoubleComplex_ptr dx, size_t dx_offset,
    magmaDoubleComplex_ptr dtau, size_t dtau_offset, magmaDouble_ptr dxnorm, size_t dxnorm_offset,
    magmaDoubleComplex_ptr dA, size_t dA_offset, int it,
    magmaDoubleComplex_ptr V, size_t V_offset, int ldv, magmaDoubleComplex_ptr T, size_t T_offset, int ldt,
    magmaDoubleComplex_ptr dwork, size_t dwork_offset,
    magma_queue_t queue);

extern "C" magma_int_t
magmablas_dznrm2(
    int m, int num, magmaDoubleComplex_ptr da, size_t da_offset, magma_int_t ldda, magmaDouble_ptr dxnorm, size_t dxnorm_offset,
    magma_queue_t queue);

extern "C" magma_int_t
magmablas_dznrm2_adjust(
    int k, magmaDouble_ptr xnorm, size_t xnorm_offset, magmaDoubleComplex_ptr c, size_t c_offset,
    magma_queue_t queue);

extern "C" magma_int_t
magmablas_zgemm_reduce(
    magma_int_t m, magma_int_t n, magma_int_t k,
    magmaDoubleComplex alpha, const magmaDoubleComplex_ptr d_A, size_t d_A_offset, magma_int_t lda,
    const magmaDoubleComplex_ptr d_B, size_t d_B_offset, magma_int_t ldb,
    magmaDoubleComplex beta,        magmaDoubleComplex_ptr d_C, size_t d_C_offset, magma_int_t ldc,
    magma_queue_t queue);

// iwocl 2013 benchmark
void
magmablas_empty(
    magmaDouble_ptr dA,
    magmaDouble_ptr dB,
    magmaDouble_ptr dC,
    magma_queue_t queue );

  /*
   * Transpose functions
   */

void
magmablas_ztranspose_inplace(
    magma_int_t n,
    magmaDoubleComplex_ptr dA, size_t dA_offset, magma_int_t ldda,
    magma_queue_t queue );

void
magmablas_ztranspose(
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex_ptr dA,  size_t dA_offset,  magma_int_t ldda,
    magmaDoubleComplex_ptr dAT, size_t dAT_offset, magma_int_t lddat,
    magma_queue_t queue );

  /*
   * Multi-GPU copy functions
   */

void
magma_zgetmatrix_1D_col_bcyclic(
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex_ptr dA[], magma_int_t ldda,
    magmaDoubleComplex    *hA,   magma_int_t lda,
    magma_int_t ngpu, magma_int_t nb,
    magma_queue_t queues[] );

void
magma_zsetmatrix_1D_col_bcyclic(
    magma_int_t m, magma_int_t n,
    const magmaDoubleComplex *hA,   magma_int_t lda,
    magmaDoubleComplex_ptr    dA[], magma_int_t ldda,
    magma_int_t ngpu, magma_int_t nb,
    magma_queue_t queues[] );

  /*
   * Multi-GPU BLAS functions (alphabetical order)
   */

  /*
   * LAPACK auxiliary functions (alphabetical order)
   */
void
magmablas_zlacpy(
    magma_uplo_t uplo,
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_ptr       dB, size_t dB_offset, magma_int_t lddb,
    magma_queue_t queue );

void
magmablas_zlacpy_cnjg(
    magma_int_t n,
    magmaDoubleComplex_ptr dA1T, size_t dA1T_offset, magma_int_t lda1,
    magmaDoubleComplex_ptr dA2T, size_t dA2T_offset, magma_int_t lda2,
    magma_queue_t queue);

double
magmablas_zlange(
    magma_norm_t norm,
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDouble_ptr dwork, size_t dwork_offset, magma_queue_t queue );

double
magmablas_zlanhe(
    magma_norm_t norm, magma_uplo_t uplo,
    magma_int_t n,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDouble_ptr dwork, size_t dwork_offset, magma_queue_t queue );

double
magmablas_zlansy(
    magma_norm_t norm, magma_uplo_t uplo,
    magma_int_t n,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDouble_ptr dwork, size_t dwork_offset, magma_queue_t queue );

void
magmablas_zlascl_2x2(
    magma_type_t type, magma_int_t m,
    const magmaDoubleComplex_ptr dW, size_t dW_offset, magma_int_t lddw,
    magmaDoubleComplex_ptr dA, size_t dA_offset, magma_int_t ldda,
    magma_int_t *info, magma_queue_t queue );

// TODO update to offdiag, diag interface
void
magmablas_zlaset(
    magma_uplo_t uplo, magma_int_t m, magma_int_t n,
    magmaDoubleComplex offdiag, magmaDoubleComplex diag,
    magmaDoubleComplex_ptr dA, size_t dA_offset, magma_int_t ldda,
    magma_queue_t queue );

void
magmablas_zlaswp(
    magma_int_t n,
    magmaDoubleComplex_ptr dAT, size_t dAT_offset, magma_int_t ldda,
    magma_int_t k1, magma_int_t k2,
    const magma_int_t *ipiv, magma_int_t inci,
    magma_queue_t queue );

void
magmablas_zlaswp2(
    magma_int_t n,
    magmaDoubleComplex_ptr dAT, size_t dAT_offset, magma_int_t ldda,
    magma_int_t k1, magma_int_t k2,
    magmaInt_const_ptr d_ipiv, size_t d_ipiv_offset, magma_int_t inci,
    magma_queue_t queue );

void
magmablas_zlaswpx(
    magma_int_t n,
    magmaDoubleComplex_ptr dA, size_t dAT_offset, magma_int_t ldx, magma_int_t ldy,
    magma_int_t k1, magma_int_t k2,
    const magma_int_t *ipiv, magma_int_t inci,
    magma_queue_t queue );

  /*
   * Level 1 BLAS (alphabetical order)
   */
void
magmablas_zswap(
    magma_int_t n,
    magmaDoubleComplex_ptr dx, size_t offset_dx, magma_int_t incx,
    magmaDoubleComplex_ptr dy, size_t offset_dy, magma_int_t incy,
    magma_queue_t queue );

  /*
   * Level 2 BLAS (alphabetical order)
   */

  /*
   * Level 3 BLAS (alphabetical order)
   */

  /*
   * Wrappers for platform independence.
   * These wrap CUBLAS or AMD OpenCL BLAS functions.
   */

// ========================================
// copying vectors
// set copies host to device
// get copies device to host
// copy copies device to device
// (with CUDA unified addressing, copy can be between same or different devices)
// Add the function, file, and line for error-reporting purposes.

void
magma_zsetvector(
    magma_int_t n,
    magmaDoubleComplex const*    hx_src,                   magma_int_t incx,
    magmaDoubleComplex_ptr       dy_dst, size_t dy_offset, magma_int_t incy,
    magma_queue_t queue );

void
magma_zsetvector_async(
    magma_int_t n,
    magmaDoubleComplex const*    hx_src,                   magma_int_t incx,
    magmaDoubleComplex_ptr       dy_dst, size_t dy_offset, magma_int_t incy,
    magma_queue_t queue, magma_event_t *event );

void
magma_zgetvector(
    magma_int_t n,
    magmaDoubleComplex_const_ptr dx_src, size_t dx_offset, magma_int_t incx,
    magmaDoubleComplex*          hy_dst,                   magma_int_t incy,
    magma_queue_t queue );

void
magma_zgetvector_async(
    magma_int_t n,
    magmaDoubleComplex_const_ptr dx_src, size_t dx_offset, magma_int_t incx,
    magmaDoubleComplex*          hy_dst,                   magma_int_t incy,
    magma_queue_t queue, magma_event_t *event );

void
magma_zcopyvector(
    magma_int_t n,
    magmaDoubleComplex_const_ptr dx_src, size_t dx_offset, magma_int_t incx,
    magmaDoubleComplex_ptr       dy_dst, size_t dy_offset, magma_int_t incy,
    magma_queue_t queue );

void
magma_zcopyvector_async(
    magma_int_t n,
    magmaDoubleComplex_const_ptr dx_src, size_t dx_offset, magma_int_t incx,
    magmaDoubleComplex_ptr       dy_dst, size_t dy_offset, magma_int_t incy,
    magma_queue_t queue, magma_event_t *event );

// ========================================
// copying sub-matrices (contiguous columns)
// set  copies host to device
// get  copies device to host
// copy copies device to device
// (with CUDA unified addressing, copy can be between same or different devices)
// Add the function, file, and line for error-reporting purposes.

void
magma_zsetmatrix(
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex const*    hA_src,                   magma_int_t ldha,
    magmaDoubleComplex_ptr       dA_dst, size_t dA_offset, magma_int_t ldda,
    magma_queue_t queue );

void
magma_zsetmatrix_async(
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex const*    hA_src,                   magma_int_t ldha,
    magmaDoubleComplex_ptr       dA_dst, size_t dA_offset, magma_int_t ldda,
    magma_queue_t queue, magma_event_t *event );

void
magma_zgetmatrix(
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex_const_ptr dA_src, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex*          hA_dst,                   magma_int_t ldha,
    magma_queue_t queue );

void
magma_zgetmatrix_async(
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex_const_ptr dA_src, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex*          hA_dst,                   magma_int_t ldha,
    magma_queue_t queue, magma_event_t *event );

void
magma_zcopymatrix(
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex_const_ptr dA_src, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_ptr       dB_dst, size_t dB_offset, magma_int_t lddb,
    magma_queue_t queue );

void
magma_zcopymatrix_async(
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex_const_ptr dA_src, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_ptr       dB_dst, size_t dB_offset, magma_int_t lddb,
    magma_queue_t queue, magma_event_t *event );

// ========================================
// Level 1 BLAS (alphabetical order)

magma_int_t
magma_izamax(
    magma_int_t n,
    const magmaDoubleComplex_ptr dx, size_t dx_offset, magma_int_t incx,
    magma_queue_t queue );

void
magma_zcopy(
    magma_int_t n,
    magmaDoubleComplex_const_ptr dx_src, size_t dx_offset, magma_int_t incx,
    magmaDoubleComplex_ptr       dy_dst, size_t dy_offset, magma_int_t incy,
    magma_queue_t queue );

void
magma_zscal(
    magma_int_t n,
    magmaDoubleComplex alpha,
    magmaDoubleComplex_ptr dx, size_t dx_offset, magma_int_t incx,
    magma_queue_t queue );

void
magma_zdscal(
    magma_int_t n,
    double alpha,
    magmaDoubleComplex_ptr dx, size_t dx_offset, magma_int_t incx,
    magma_queue_t queue );

void
magma_zswap(
    magma_int_t n,
    magmaDoubleComplex_ptr dx, size_t dx_offset, magma_int_t incx,
    magmaDoubleComplex_ptr dy, size_t dy_offset, magma_int_t incy,
    magma_queue_t queue );

// ========================================
// Level 2 BLAS (alphabetical order)

void
magma_zgemv(
    magma_trans_t transA,
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex alpha,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_const_ptr dx, size_t dx_offset, magma_int_t incx,
    magmaDoubleComplex beta,
    magmaDoubleComplex_ptr       dy, size_t dy_offset, magma_int_t incy,
    magma_queue_t queue );

void
magma_zhemv(
    magma_uplo_t uplo,
    magma_int_t n,
    magmaDoubleComplex alpha,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_const_ptr dx, size_t dx_offset, magma_int_t incx,
    magmaDoubleComplex beta,
    magmaDoubleComplex_ptr       dy, size_t dy_offset, magma_int_t incy,
    magma_queue_t queue );

void
magma_ztrsv(
    magma_uplo_t uplo, magma_trans_t trans, magma_diag_t diag,
    magma_int_t n,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_ptr       dx, size_t dx_offset, magma_int_t incx,
    magma_queue_t queue );

// ========================================
// Level 3 BLAS (alphabetical order)

void
magma_zgemm(
    magma_trans_t transA, magma_trans_t transB,
    magma_int_t m, magma_int_t n, magma_int_t k,
    magmaDoubleComplex alpha,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_const_ptr dB, size_t dB_offset, magma_int_t lddb,
    magmaDoubleComplex beta,
    magmaDoubleComplex_ptr       dC, size_t dC_offset, magma_int_t lddc,
    magma_queue_t queue );

void
magma_zhemm(
    magma_side_t side, magma_uplo_t uplo,
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex alpha,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_const_ptr dB, size_t dB_offset, magma_int_t lddb,
    magmaDoubleComplex beta,
    magmaDoubleComplex_ptr       dC, size_t dC_offset, magma_int_t lddc,
    magma_queue_t queue );

void
magma_zher2k(
    magma_uplo_t uplo, magma_trans_t trans,
    magma_int_t n, magma_int_t k,
    magmaDoubleComplex alpha,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_const_ptr dB, size_t dB_offset, magma_int_t lddb,
    double beta,
    magmaDoubleComplex_ptr       dC, size_t dC_offset, magma_int_t lddc,
    magma_queue_t queue );

void
magma_zherk(
    magma_uplo_t uplo, magma_trans_t trans,
    magma_int_t n, magma_int_t k,
    double alpha,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    double beta,
    magmaDoubleComplex_ptr       dC, size_t dC_offset, magma_int_t lddc,
    magma_queue_t queue );

void
magma_ztrmm(
    magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_diag_t diag,
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex alpha,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_ptr       dB, size_t dB_offset, magma_int_t lddb,
    magma_queue_t queue );

void
magma_ztrsm(
    magma_side_t side, magma_uplo_t uplo, magma_trans_t trans, magma_diag_t diag,
    magma_int_t m, magma_int_t n,
    magmaDoubleComplex alpha,
    magmaDoubleComplex_const_ptr dA, size_t dA_offset, magma_int_t ldda,
    magmaDoubleComplex_ptr       dB, size_t dB_offset, magma_int_t lddb,
    magma_queue_t queue );

#ifdef __cplusplus
}
#endif

#undef COMPLEX

#endif  /* MAGMABLAS_Z_H */


text:
module.exports = Transformer;

var traverse = require("../traverse");
var t        = require("../types");
var _        = require("lodash");

function Transformer(key, transformer, opts) {
  this.manipulateOptions = transformer.manipulateOptions;
  this.experimental      = !!transformer.experimental;
  this.transformer       = Transformer.normalise(transformer);
  this.optional          = !!transformer.optional;
  this.opts              = opts || {};
  this.key               = key;
}

Transformer.normalise = function (transformer) {
  if (_.isFunction(transformer)) {
    transformer = { ast: transformer };
  }

  _.each(transformer, function (fns, type) {
    // hidden property
    if (type[0] === "_") return;

    if (_.isFunction(fns)) fns = { enter: fns };

    if (!_.isObject(fns)) return;

    transformer[type] = fns;

    var aliases = t.FLIPPED_ALIAS_KEYS[type];
    if (aliases) {
      _.each(aliases, function (alias) {
        transformer[alias] = fns;
      });
    }
  });

  return transformer;
};

Transformer.prototype.astRun = function (file, key) {
  var transformer = this.transformer;
  var ast         = file.ast;

  if (transformer.ast && transformer.ast[key]) {
    transformer.ast[key](ast, file);
  }
};

Transformer.prototype.transform = function (file) {
  var transformer = this.transformer;
  var ast         = file.ast;

  var build = function (exit) {
    return function (node, parent, scope) {
      var fns = transformer[node.type];
      if (!fns) return;

      var fn = fns.enter;
      if (exit) fn = fns.exit;
      if (!fn) return;

      return fn(node, parent, file, scope);
    };
  };

  this.astRun(file, "before");

  traverse(ast, {
    enter: build(),
    exit:  build(true)
  });

  this.astRun(file, "after");
};

Transformer.prototype.canRun = function (file) {
  var opts = file.opts;
  var key  = this.key;
  if (key[0] === "_") return true;

  var blacklist = opts.blacklist;
  if (blacklist.length && _.contains(blacklist, key)) return false;

  var whitelist = opts.whitelist;
  if (whitelist.length && !_.contains(whitelist, key)) return false;

  if (this.optional && !_.contains(opts.optional, key)) return false;

  if (this.experimental && !opts.experimental) return false;

  return true;
};

redpajama_set_name: RedPajamaGithub


text:
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil

"""
This test ensures that we only create Clang AST nodes in our module AST
when we actually need them.

All tests in this file behave like this:
  1. Use LLDB to do something (expression evaluation, breakpoint setting, etc.).
  2. Check that certain Clang AST nodes were not loaded during the previous
     step.
"""

class TestCase(TestBase):

    NO_DEBUG_INFO_TESTCASE = True
    mydir = TestBase.compute_mydir(__file__)

    def setUp(self):
      TestBase.setUp(self)
      # Only build this test once.
      self.build()

    # Clang declaration kind we are looking for.
    class_decl_kind = "CXXRecordDecl"
    # FIXME: This shouldn't be a CXXRecordDecl, but that's how we model
    # structs in Clang.
    struct_decl_kind = "CXXRecordDecl"

    # The decls we use in this program in the format that
    # decl_in_line and decl_completed_in_line expect (which is a pair of
    # node type and the unqualified declaration name.
    struct_first_member_decl = [struct_decl_kind, "StructFirstMember"]
    struct_behind_ptr_decl = [struct_decl_kind, "StructBehindPointer"]
    struct_behind_ref_decl = [struct_decl_kind, "StructBehindRef"]
    struct_member_decl = [struct_decl_kind, "StructMember"]
    some_struct_decl = [struct_decl_kind, "SomeStruct"]
    other_struct_decl = [struct_decl_kind, "OtherStruct"]
    class_in_namespace_decl = [class_decl_kind, "ClassInNamespace"]
    class_we_enter_decl = [class_decl_kind, "ClassWeEnter"]
    class_member_decl = [struct_decl_kind, "ClassMember"]
    unused_class_member_decl = [struct_decl_kind, "UnusedClassMember"]
    unused_class_member_ptr_decl = [struct_decl_kind, "UnusedClassMemberPtr"]

    def assert_no_decls_loaded(self):
        """
        Asserts that no known declarations in this test are loaded
        into the module's AST.
        """
        self.assert_decl_not_loaded(self.struct_first_member_decl)
        self.assert_decl_not_loaded(self.struct_behind_ptr_decl)
        self.assert_decl_not_loaded(self.struct_behind_ref_decl)
        self.assert_decl_not_loaded(self.struct_member_decl)
        self.assert_decl_not_loaded(self.some_struct_decl)
        self.assert_decl_not_loaded(self.other_struct_decl)
        self.assert_decl_not_loaded(self.class_in_namespace_decl)
        self.assert_decl_not_loaded(self.class_member_decl)
        self.assert_decl_not_loaded(self.unused_class_member_decl)

    def get_ast_dump(self):
        """Returns the dumped Clang AST of the module as a string"""
        res = lldb.SBCommandReturnObject()
        ci = self.dbg.GetCommandInterpreter()
        ci.HandleCommand('target modules dump ast a.out', res)
        self.assertTrue(res.Succeeded())
        return res.GetOutput()

    def decl_in_line(self, line, decl):
        """
        Returns true iff the given line declares the given Clang decl.
        The line is expected to be in the form of Clang's AST dump.
        """
        line = line.rstrip() + "\n"
        decl_kind = "-" + decl[0] + " "
        # Either the decl is somewhere in the line or at the end of
        # the line.
        decl_name = " " + decl[1] + " "
        decl_name_eol = " " + decl[1] + "\n"
        if not decl_kind in line:
          return False
        return decl_name in line or decl_name_eol in line

    def decl_completed_in_line(self, line, decl):
        """
        Returns true iff the given line declares the given Clang decl and
        the decl was completed (i.e., it has no undeserialized declarations
        in it).
        """
        return self.decl_in_line(line, decl) and not "<undeserialized declarations>" in line

    # The following asserts are used for checking if certain Clang declarations
    # were loaded or not since the target was created.

    def assert_decl_loaded(self, decl):
        """
        Asserts the given decl is currently loaded.
        Note: This test is about checking that types/declarations are not
        loaded. If this assert fails it is usually fine to turn it into a
        assert_decl_not_loaded or assert_decl_not_completed assuming LLDB's
        functionality has not suffered by not loading this declaration.
        """
        ast = self.get_ast_dump()
        found = False
        for line in ast.splitlines():
          if self.decl_in_line(line, decl):
            found = True
            self.assertTrue(self.decl_completed_in_line(line, decl),
                            "Should have called assert_decl_not_completed")
        self.assertTrue(found, "Declaration no longer loaded " + str(decl) +
            ".\nAST:\n" + ast)

    def assert_decl_not_completed(self, decl):
        """
        Asserts that the given decl is currently not completed in the module's
        AST. It may be loaded but then can can only contain undeserialized
        declarations.
        """
        ast = self.get_ast_dump()
        found = False
        for line in ast.splitlines():
          error_msg = "Unexpected completed decl: '" + line + "'.\nAST:\n" + ast
          self.assertFalse(self.decl_completed_in_line(line, decl), error_msg)

    def assert_decl_not_loaded(self, decl):
        """
        Asserts that the given decl is currently not loaded in the module's
        AST.
        """
        ast = self.get_ast_dump()
        found = False
        for line in ast.splitlines():
          error_msg = "Unexpected loaded decl: '" + line + "'\nAST:\n" + ast
          self.assertFalse(self.decl_in_line(line, decl), error_msg)

    def clean_setup(self, location):
        """
        Runs to the line with the source line with the given location string
        and ensures that our module AST is empty.
        """
        lldbutil.run_to_source_breakpoint(self,
            "// Location: " + location, lldb.SBFileSpec("main.cpp"))
        # Make sure no declarations are loaded initially.
        self.assert_no_decls_loaded()

    @add_test_categories(["dwarf"])
    def test_arithmetic_expression_in_main(self):
        """ Runs a simple arithmetic expression which should load nothing. """
        self.clean_setup(location="multiple locals function")

        self.expect("expr 1 + (int)2.0", substrs=['(int) $0'])

        # This should not have loaded any decls.
        self.assert_no_decls_loaded()

    @add_test_categories(["dwarf"])
    def test_printing_local_variable_in_other_struct_func(self):
        """
        Prints a local variable and makes sure no unrelated types are loaded.
        """
        self.clean_setup(location="other struct function")

        self.expect("expr other_struct_var", substrs=['(OtherStruct) $0'])
        # The decl we run on was loaded.
        self.assert_decl_loaded(self.other_struct_decl)

        # This should not have loaded anything else.
        self.assert_decl_not_loaded(self.some_struct_decl)
        self.assert_decl_not_loaded(self.class_in_namespace_decl)

    @add_test_categories(["dwarf"])
    def test_printing_struct_with_multiple_locals(self):
        """
        Prints a local variable and checks that we don't load other local
        variables.
        """
        self.clean_setup(location="multiple locals function")

        self.expect("expr struct_var", substrs=['(SomeStruct) $0'])

        # We loaded SomeStruct and its member types for printing.
        self.assert_decl_loaded(self.some_struct_decl)
        self.assert_decl_loaded(self.struct_behind_ptr_decl)
        self.assert_decl_loaded(self.struct_behind_ref_decl)

        # FIXME: We don't use these variables, but we seem to load all local
        # local variables.
        self.assert_decl_not_completed(self.other_struct_decl)
        self.assert_decl_not_completed(self.class_in_namespace_decl)

    @add_test_categories(["dwarf"])
    def test_addr_of_struct(self):
        """
        Prints the address of a local variable (which is a struct).
        """
        self.clean_setup(location="multiple locals function")

        self.expect("expr &struct_var", substrs=['(SomeStruct *) $0'])

        # We loaded SomeStruct.
        self.assert_decl_loaded(self.some_struct_decl)

        # The member declarations should not be completed.
        self.assert_decl_not_completed(self.struct_behind_ptr_decl)
        self.assert_decl_not_completed(self.struct_behind_ref_decl)

        # FIXME: The first member was behind a pointer so it shouldn't be
        # completed. Somehow LLDB really wants to load the first member, so
        # that is why have it defined here.
        self.assert_decl_loaded(self.struct_first_member_decl)

        # FIXME: We don't use these variables, but we seem to load all local
        # local variables.
        self.assert_decl_not_completed(self.other_struct_decl)
        self.assert_decl_not_completed(self.class_in_namespace_decl)

    @add_test_categories(["dwarf"])
    def test_class_function_access_member(self):
        self.clean_setup(location="class function")

        self.expect("expr member", substrs=['(ClassMember) $0'])

        # We loaded the current class we touched.
        self.assert_decl_loaded(self.class_we_enter_decl)
        # We loaded the unused members of this class.
        self.assert_decl_loaded(self.unused_class_member_decl)
        self.assert_decl_not_completed(self.unused_class_member_ptr_decl)
        # We loaded the member we used.
        self.assert_decl_loaded(self.class_member_decl)

        # This should not have loaded anything else.
        self.assert_decl_not_loaded(self.other_struct_decl)
        self.assert_decl_not_loaded(self.some_struct_decl)
        self.assert_decl_not_loaded(self.class_in_namespace_decl)


text:
void pileup_and_call(){
	int tid;
	int pos;
	int cov;
	bam_pileup1_t *pileup = nullptr;

	bam_plp_t iter = bam_plp_init(&plp_get_read, &reader);
	while( (pileup = bam_plp_auto(iter,&tid,&pos,&cov)) != nullptr){ //successfully pile up new position
		char refbase = ref.get_ref(reader.get_ref_name(tid))[pos];//get ref allele
		std::vector<char> alleles = get_piled_alleles(pileup, cov)//get array of alt + ref alleles
		std::vector<char> variants = call_variants(alleles);//call variant(s) using array of alt alleles
		bcf1_t* b = create_vcf_line(writer.header, refbase, variants);//TODO:create vcf entry
		writer.write_variant(b);//write vcf entry
		bcf_destroy(b);//deallocate bcf
	}
}

std::vector<char> call_variants(std::vector<char> alleles){
	int coverage = alleles.size();
	int cutoff = get_cutoff(coverage);
	std::map<char, int> counts;
	std::vector<char> variants;
	for(auto it = alleles.begin(); it != alleles.end(); ++it){
		counts[*it] = counts[*it] + 1;
	}

	for(auto it = counts.begin(); it != counts.end(); ++it){
		if (it->second >= cutoff){ //it's a variant!
			variants.push_back(it->first)
		}
	}
	return variants;
}

//TODO: cache this somewhere or we're gonna be slow
static long double binomial_cdf(int successes, int trials, long double p){
	long double cdf = 0.0;
	for(int i = 0; i < k; i++){
		cdf += binomial_pdf(i, trials, p);
	}
	return cdf;
}

static long double binomial_pdf(int successes, int trials, long double p){
	return binomial_coeff(trials, successes) * (p ** successes) * (1 - p) ** (trials - successes);
}

//n choose k
static int binomial_coeff(int n, int k){
	if (k > n){
		throw std::runtime_error("error calculating binomial with n = " << n << " and k = " << k << std::endl);
	}
	int product = 1;
	for(int i=1; i <= k; i++){
		product *= ((n + 1 - i) / i);
	}
	return product;
}

static long double p_incorrect_call(int count, int coverage, long double error){
	long double probability = 0.0;
	for (int i = count; i <= coverage; ++i){
		probability += binomial_pdf(i, coverage, error)
	}
	return probability;
}

static int p_threshold(int coverage, long double error, long double cutoff_error){
	//returns the minimum count such that the probability of an erronious call is less than cutoff_error
	for (int i = 0; i <= coverage; i++){
		if (p_incorrect_call(i,coverage,error) < cutoff_error){
			return i;
		}
	}
	return 0;
}

int get_cutoff(int coverage){
	int maxindex = cutoffs.size() - 1;
	if (coverage > maxindex){
		cutoffs.reserve(coverage + 1);
		for(int i = maxindex; i <= coverage; ++i){
			cutoffs[i] = p_threshold(i, error, cutoff_error);
		}
	}
	return cutoffs[coverage];
}

//possible optimization: store sequence strings in a hash w/ alignment, throw out of hash once no longer in pileup
std::vector<char> get_piled_alleles(bam_pileup1_t* pileup, int cov){
	std::vector<char> alleles();
	alleles.reserve(cov);
	for (i = 0; i < cov; i++){
		bam1_t* alignment = pileup[i].b;
		uint8_t *seq = bam_get_seq(alignment);
		int pos = pileup[i].qpos;
		int baseint = bam_seqi(seq,pos)
		alleles[i] = seq_nt16_str[baseint];
	}
	return alleles;
}

//TODO:
bcf1_t* create_vcf_line(bcf_hdr_t *hdr, char ref, std::vector<char> variants){
	bcf1_t* line = bcf_init1();
	std::vector<char> alleles {ref};
	alleles.insert(alleles.end(),variants.begin(),variants.end());
	bcf_update_alleles(hdr, line, &alleles[0],alleles.size());

}

//typedef int (*bam_plp_auto_f)(void *data, bam1_t *b);
int plp_get_read(void *data, bam1_t *b){
	SamReader *reader = data;
	reader->next(b);
}


text:
package org.ow2.chameleon.everest.client.casaTest.device;

/**
 * Created with IntelliJ IDEA.
 * User: root
 * Date: 09/07/13
 * Time: 16:11
 * To change this template use File | Settings | File Templates.
 */
public class GenericDevice {

    String DEVICE_SERIAL_NUMBER = "device.serialNumber";

    public String STATE_PROPERTY_NAME = "state";
    public String STATE_ACTIVATED = "activated";
    public String STATE_DEACTIVATED = "deactivated";
    public String STATE_UNKNOWN = "unknown";
    public String zone = "null";

    public String getSTATE_DEACTIVATED() {
        return STATE_DEACTIVATED;
    }

    public void setSTATE_DEACTIVATED(String STATE_DEACTIVATED) {
        this.STATE_DEACTIVATED = STATE_DEACTIVATED;
    }

    public String getSTATE_PROPERTY_NAME() {
        return STATE_PROPERTY_NAME;
    }

    public void setSTATE_PROPERTY_NAME(String STATE_PROPERTY_NAME) {
        this.STATE_PROPERTY_NAME = STATE_PROPERTY_NAME;
    }

    public String getSTATE_ACTIVATED() {
        return STATE_ACTIVATED;
    }

    public void setSTATE_ACTIVATED(String STATE_ACTIVATED) {
        this.STATE_ACTIVATED = STATE_ACTIVATED;
    }

    public String getSTATE_UNKNOWN() {
        return STATE_UNKNOWN;
    }

    public void setSTATE_UNKNOWN(String STATE_UNKNOWN) {
        this.STATE_UNKNOWN = STATE_UNKNOWN;
    }

    public GenericDevice(String DEVICE_SERIAL_NUMBER) {
        this.DEVICE_SERIAL_NUMBER = DEVICE_SERIAL_NUMBER;
    }

}


text:
/* Component containers
----------------------------------*/
.ui-widget {
	font-family: Georgia,Verdana,Arial,sans-serif;
	font-size: 1.2em;
}
.ui-widget .ui-widget {
	font-size: 1em;
}
.ui-widget input,
.ui-widget select,
.ui-widget textarea,
.ui-widget button {
	font-family: Georgia,Verdana,Arial,sans-serif;
	font-size: 1em;
}
.ui-widget-content {
	border: 1px solid #efec9f;
	background: #443113 url(images/ui-bg_diamond_8_443113_10x8.png) 50% 50% repeat;
	color: #efec9f;
}
.ui-widget-content a {
	color: #efec9f;
}
.ui-widget-header {
	border: 1px solid #baaa5a;
	background: #261803 url(images/ui-bg_diamond_8_261803_10x8.png) 50% 50% repeat;
	color: #eacd86;
	font-weight: bold;
}
.ui-widget-header a {
	color: #eacd86;
}

/* Interaction states
----------------------------------*/
.ui-state-default,
.ui-widget-content .ui-state-default,
.ui-widget-header .ui-state-default {
	border: 1px solid #362917;
	background: #4f4221 url(images/ui-bg_diamond_10_4f4221_10x8.png) 50% 50% repeat;
	font-weight: bold;
	color: #f8eec9;
}
.ui-state-default a,
.ui-state-default a:link,
.ui-state-default a:visited {
	color: #f8eec9;
	text-decoration: none;
}
.ui-state-hover,
.ui-widget-content .ui-state-hover,
.ui-widget-header .ui-state-hover,
.ui-state-focus,
.ui-widget-content .ui-state-focus,
.ui-widget-header .ui-state-focus {
	border: 1px solid #362917;
	background: #675423 url(images/ui-bg_diamond_25_675423_10x8.png) 50% 50% repeat;
	font-weight: bold;
	color: #f8eec9;
}
.ui-state-hover a,
.ui-state-hover a:hover,
.ui-state-hover a:link,
.ui-state-hover a:visited {
	color: #f8eec9;
	text-decoration: none;
}
.ui-state-active,
.ui-widget-content .ui-state-active,
.ui-widget-header .ui-state-active {
	border: 1px solid #efec9f;
	background: #443113 url(images/ui-bg_diamond_8_443113_10x8.png) 50% 50% repeat;
	font-weight: bold;
	color: #f9f2bd;
}
.ui-state-active a,
.ui-state-active a:link,
.ui-state-active a:visited {
	color: #f9f2bd;
	text-decoration: none;
}

/* Interaction Cues
----------------------------------*/
.ui-state-highlight,
.ui-widget-content .ui-state-highlight,
.ui-widget-header .ui-state-highlight {
	border: 1px solid #362917;
	background: #d5ac5d url(images/ui-bg_diamond_25_d5ac5d_10x8.png) 50% 50% repeat;
	color: #060200;
}
.ui-state-highlight a,
.ui-widget-content .ui-state-highlight a,
.ui-widget-header .ui-state-highlight a {
	color: #060200;
}
.ui-state-error,
.ui-widget-content .ui-state-error,
.ui-widget-header .ui-state-error {
	border: 1px solid #c26629;
	background: #fee4bd url(images/ui-bg_highlight-hard_65_fee4bd_1x100.png) 50% top repeat-x;
	color: #803f1e;
}
.ui-state-error a,
.ui-widget-content .ui-state-error a,
.ui-widget-header .ui-state-error a {
	color: #803f1e;
}
.ui-state-error-text,
.ui-widget-content .ui-state-error-text,
.ui-widget-header .ui-state-error-text {
	color: #803f1e;
}
.ui-priority-primary,
.ui-widget-content .ui-priority-primary,
.ui-widget-header .ui-priority-primary {
	font-weight: bold;
}
.ui-priority-secondary,
.ui-widget-content .ui-priority-secondary,
.ui-widget-header .ui-priority-secondary {
	opacity: .7;
	filter:Alpha(Opacity=70);
	font-weight: normal;
}
.ui-state-disabled,
.ui-widget-content .ui-state-disabled,
.ui-widget-header .ui-state-disabled {
	opacity: .35;
	filter:Alpha(Opacity=35);
	background-image: none;
}
.ui-state-disabled .ui-icon {
	filter:Alpha(Opacity=35); /* For IE8 - See #6059 */
}

/* Icons
----------------------------------*/

/* states and images */
.ui-icon {
	width: 16px;
	height: 16px;
}
.ui-icon,
.ui-widget-content .ui-icon {
	background-image: url(images/ui-icons_efec9f_256x240.png);
}
.ui-widget-header .ui-icon {
	background-image: url(images/ui-icons_e9cd86_256x240.png);
}
.ui-state-default .ui-icon {
	background-image: url(images/ui-icons_e8e2b5_256x240.png);
}
.ui-state-hover .ui-icon,
.ui-state-focus .ui-icon {
	background-image: url(images/ui-icons_f2ec64_256x240.png);
}
.ui-state-active .ui-icon {
	background-image: url(images/ui-icons_f9f2bd_256x240.png);
}
.ui-state-highlight .ui-icon {
	background-image: url(images/ui-icons_070603_256x240.png);
}
.ui-state-error .ui-icon,
.ui-state-error-text .ui-icon {
	background-image: url(images/ui-icons_ff7519_256x240.png);
}

/* positioning */
.ui-icon-blank { background-position: 16px 16px; }
.ui-icon-carat-1-n { background-position: 0 0; }
.ui-icon-carat-1-ne { background-position: -16px 0; }
.ui-icon-carat-1-e { background-position: -32px 0; }
.ui-icon-carat-1-se { background-position: -48px 0; }
.ui-icon-carat-1-s { background-position: -64px 0; }
.ui-icon-carat-1-sw { background-position: -80px 0; }
.ui-icon-carat-1-w { background-position: -96px 0; }
.ui-icon-carat-1-nw { background-position: -112px 0; }
.ui-icon-carat-2-n-s { background-position: -128px 0; }
.ui-icon-carat-2-e-w { background-position: -144px 0; }
.ui-icon-triangle-1-n { background-position: 0 -16px; }
.ui-icon-triangle-1-ne { background-position: -16px -16px; }
.ui-icon-triangle-1-e { background-position: -32px -16px; }
.ui-icon-triangle-1-se { background-position: -48px -16px; }
.ui-icon-triangle-1-s { background-position: -64px -16px; }
.ui-icon-triangle-1-sw { background-position: -80px -16px; }
.ui-icon-triangle-1-w { background-position: -96px -16px; }
.ui-icon-triangle-1-nw { background-position: -112px -16px; }
.ui-icon-triangle-2-n-s { background-position: -128px -16px; }
.ui-icon-triangle-2-e-w { background-position: -144px -16px; }
.ui-icon-arrow-1-n { background-position: 0 -32px; }
.ui-icon-arrow-1-ne { background-position: -16px -32px; }
.ui-icon-arrow-1-e { background-position: -32px -32px; }
.ui-icon-arrow-1-se { background-position: -48px -32px; }
.ui-icon-arrow-1-s { background-position: -64px -32px; }
.ui-icon-arrow-1-sw { background-position: -80px -32px; }
.ui-icon-arrow-1-w { background-position: -96px -32px; }
.ui-icon-arrow-1-nw { background-position: -112px -32px; }
.ui-icon-arrow-2-n-s { background-position: -128px -32px; }
.ui-icon-arrow-2-ne-sw { background-position: -144px -32px; }
.ui-icon-arrow-2-e-w { background-position: -160px -32px; }
.ui-icon-arrow-2-se-nw { background-position: -176px -32px; }
.ui-icon-arrowstop-1-n { background-position: -192px -32px; }
.ui-icon-arrowstop-1-e { background-position: -208px -32px; }
.ui-icon-arrowstop-1-s { background-position: -224px -32px; }
.ui-icon-arrowstop-1-w { background-position: -240px -32px; }
.ui-icon-arrowthick-1-n { background-position: 0 -48px; }
.ui-icon-arrowthick-1-ne { background-position: -16px -48px; }
.ui-icon-arrowthick-1-e { background-position: -32px -48px; }
.ui-icon-arrowthick-1-se { background-position: -48px -48px; }
.ui-icon-arrowthick-1-s { background-position: -64px -48px; }
.ui-icon-arrowthick-1-sw { background-position: -80px -48px; }
.ui-icon-arrowthick-1-w { background-position: -96px -48px; }
.ui-icon-arrowthick-1-nw { background-position: -112px -48px; }
.ui-icon-arrowthick-2-n-s { background-position: -128px -48px; }
.ui-icon-arrowthick-2-ne-sw { background-position: -144px -48px; }
.ui-icon-arrowthick-2-e-w { background-position: -160px -48px; }
.ui-icon-arrowthick-2-se-nw { background-position: -176px -48px; }
.ui-icon-arrowthickstop-1-n { background-position: -192px -48px; }
.ui-icon-arrowthickstop-1-e { background-position: -208px -48px; }
.ui-icon-arrowthickstop-1-s { background-position: -224px -48px; }
.ui-icon-arrowthickstop-1-w { background-position: -240px -48px; }
.ui-icon-arrowreturnthick-1-w { background-position: 0 -64px; }
.ui-icon-arrowreturnthick-1-n { background-position: -16px -64px; }
.ui-icon-arrowreturnthick-1-e { background-position: -32px -64px; }
.ui-icon-arrowreturnthick-1-s { background-position: -48px -64px; }
.ui-icon-arrowreturn-1-w { background-position: -64px -64px; }
.ui-icon-arrowreturn-1-n { background-position: -80px -64px; }
.ui-icon-arrowreturn-1-e { background-position: -96px -64px; }
.ui-icon-arrowreturn-1-s { background-position: -112px -64px; }
.ui-icon-arrowrefresh-1-w { background-position: -128px -64px; }
.ui-icon-arrowrefresh-1-n { background-position: -144px -64px; }
.ui-icon-arrowrefresh-1-e { background-position: -160px -64px; }
.ui-icon-arrowrefresh-1-s { background-position: -176px -64px; }
.ui-icon-arrow-4 { background-position: 0 -80px; }
.ui-icon-arrow-4-diag { background-position: -16px -80px; }
.ui-icon-extlink { background-position: -32px -80px; }
.ui-icon-newwin { background-position: -48px -80px; }
.ui-icon-refresh { background-position: -64px -80px; }
.ui-icon-shuffle { background-position: -80px -80px; }
.ui-icon-transfer-e-w { background-position: -96px -80px; }
.ui-icon-transferthick-e-w { background-position: -112px -80px; }
.ui-icon-folder-collapsed { background-position: 0 -96px; }
.ui-icon-folder-open { background-position: -16px -96px; }
.ui-icon-document { background-position: -32px -96px; }
.ui-icon-document-b { background-position: -48px -96px; }
.ui-icon-note { background-position: -64px -96px; }
.ui-icon-mail-closed { background-position: -80px -96px; }
.ui-icon-mail-open { background-position: -96px -96px; }
.ui-icon-suitcase { background-position: -112px -96px; }
.ui-icon-comment { background-position: -128px -96px; }
.ui-icon-person { background-position: -144px -96px; }
.ui-icon-print { background-position: -160px -96px; }
.ui-icon-trash { background-position: -176px -96px; }
.ui-icon-locked { background-position: -192px -96px; }
.ui-icon-unlocked { background-position: -208px -96px; }
.ui-icon-bookmark { background-position: -224px -96px; }
.ui-icon-tag { background-position: -240px -96px; }
.ui-icon-home { background-position: 0 -112px; }
.ui-icon-flag { background-position: -16px -112px; }
.ui-icon-calendar { background-position: -32px -112px; }
.ui-icon-cart { background-position: -48px -112px; }
.ui-icon-pencil { background-position: -64px -112px; }
.ui-icon-clock { background-position: -80px -112px; }
.ui-icon-disk { background-position: -96px -112px; }
.ui-icon-calculator { background-position: -112px -112px; }
.ui-icon-zoomin { background-position: -128px -112px; }
.ui-icon-zoomout { background-position: -144px -112px; }
.ui-icon-search { background-position: -160px -112px; }
.ui-icon-wrench { background-position: -176px -112px; }
.ui-icon-gear { background-position: -192px -112px; }
.ui-icon-heart { background-position: -208px -112px; }
.ui-icon-star { background-position: -224px -112px; }
.ui-icon-link { background-position: -240px -112px; }
.ui-icon-cancel { background-position: 0 -128px; }
.ui-icon-plus { background-position: -16px -128px; }
.ui-icon-plusthick { background-position: -32px -128px; }
.ui-icon-minus { background-position: -48px -128px; }
.ui-icon-minusthick { background-position: -64px -128px; }
.ui-icon-close { background-position: -80px -128px; }
.ui-icon-closethick { background-position: -96px -128px; }
.ui-icon-key { background-position: -112px -128px; }
.ui-icon-lightbulb { background-position: -128px -128px; }
.ui-icon-scissors { background-position: -144px -128px; }
.ui-icon-clipboard { background-position: -160px -128px; }
.ui-icon-copy { background-position: -176px -128px; }
.ui-icon-contact { background-position: -192px -128px; }
.ui-icon-image { background-position: -208px -128px; }
.ui-icon-video { background-position: -224px -128px; }
.ui-icon-script { background-position: -240px -128px; }
.ui-icon-alert { background-position: 0 -144px; }
.ui-icon-info { background-position: -16px -144px; }
.ui-icon-notice { background-position: -32px -144px; }
.ui-icon-help { background-position: -48px -144px; }
.ui-icon-check { background-position: -64px -144px; }
.ui-icon-bullet { background-position: -80px -144px; }
.ui-icon-radio-on { background-position: -96px -144px; }
.ui-icon-radio-off { background-position: -112px -144px; }
.ui-icon-pin-w { background-position: -128px -144px; }
.ui-icon-pin-s { background-position: -144px -144px; }
.ui-icon-play { background-position: 0 -160px; }
.ui-icon-pause { background-position: -16px -160px; }
.ui-icon-seek-next { background-position: -32px -160px; }
.ui-icon-seek-prev { background-position: -48px -160px; }
.ui-icon-seek-end { background-position: -64px -160px; }
.ui-icon-seek-start { background-position: -80px -160px; }
/* ui-icon-seek-first is deprecated, use ui-icon-seek-start instead */
.ui-icon-seek-first { background-position: -80px -160px; }
.ui-icon-stop { background-position: -96px -160px; }
.ui-icon-eject { background-position: -112px -160px; }
.ui-icon-volume-off { background-position: -128px -160px; }
.ui-icon-volume-on { background-position: -144px -160px; }
.ui-icon-power { background-position: 0 -176px; }
.ui-icon-signal-diag { background-position: -16px -176px; }
.ui-icon-signal { background-position: -32px -176px; }
.ui-icon-battery-0 { background-position: -48px -176px; }
.ui-icon-battery-1 { background-position: -64px -176px; }
.ui-icon-battery-2 { background-position: -80px -176px; }
.ui-icon-battery-3 { background-position: -96px -176px; }
.ui-icon-circle-plus { background-position: 0 -192px; }
.ui-icon-circle-minus { background-position: -16px -192px; }
.ui-icon-circle-close { background-position: -32px -192px; }
.ui-icon-circle-triangle-e { background-position: -48px -192px; }
.ui-icon-circle-triangle-s { background-position: -64px -192px; }
.ui-icon-circle-triangle-w { background-position: -80px -192px; }
.ui-icon-circle-triangle-n { background-position: -96px -192px; }
.ui-icon-circle-arrow-e { background-position: -112px -192px; }
.ui-icon-circle-arrow-s { background-position: -128px -192px; }
.ui-icon-circle-arrow-w { background-position: -144px -192px; }
.ui-icon-circle-arrow-n { background-position: -160px -192px; }
.ui-icon-circle-zoomin { background-position: -176px -192px; }
.ui-icon-circle-zoomout { background-position: -192px -192px; }
.ui-icon-circle-check { background-position: -208px -192px; }
.ui-icon-circlesmall-plus { background-position: 0 -208px; }
.ui-icon-circlesmall-minus { background-position: -16px -208px; }
.ui-icon-circlesmall-close { background-position: -32px -208px; }
.ui-icon-squaresmall-plus { background-position: -48px -208px; }
.ui-icon-squaresmall-minus { background-position: -64px -208px; }
.ui-icon-squaresmall-close { background-position: -80px -208px; }
.ui-icon-grip-dotted-vertical { background-position: 0 -224px; }
.ui-icon-grip-dotted-horizontal { background-position: -16px -224px; }
.ui-icon-grip-solid-vertical { background-position: -32px -224px; }
.ui-icon-grip-solid-horizontal { background-position: -48px -224px; }
.ui-icon-gripsmall-diagonal-se { background-position: -64px -224px; }
.ui-icon-grip-diagonal-se { background-position: -80px -224px; }

/* Misc visuals
----------------------------------*/

/* Corner radius */
.ui-corner-all,
.ui-corner-top,
.ui-corner-left,
.ui-corner-tl {
	border-top-left-radius: 5px;
}
.ui-corner-all,
.ui-corner-top,
.ui-corner-right,
.ui-corner-tr {
	border-top-right-radius: 5px;
}
.ui-corner-all,
.ui-corner-bottom,
.ui-corner-left,
.ui-corner-bl {
	border-bottom-left-radius: 5px;
}
.ui-corner-all,
.ui-corner-bottom,
.ui-corner-right,
.ui-corner-br {
	border-bottom-right-radius: 5px;
}

/* Overlays */
.ui-widget-overlay {
	background: #372806 url(images/ui-bg_diamond_20_372806_10x8.png) 50% 50% repeat;
	opacity: .8;
	filter: Alpha(Opacity=80);
}
.ui-widget-shadow {
	margin: -8px 0 0 -8px;
	padding: 8px;
	background: #ddd4b0 url(images/ui-bg_flat_75_ddd4b0_40x100.png) 50% 50% repeat-x;
	opacity: .3;
	filter: Alpha(Opacity=30);
	border-radius: 12px;
}


text:
${nls.statisticsSettings.addNewStatisticsText}

${nls.common.ok}

${nls.common.cancel}