I'll treat this as an atomic object type
557171
private void compareStrings(List<String> c1, List<String> c2, TreePath loc,
      String eltname) throws DeepInequalityException {
    if (c1 == null && c2 == null) {
      return;
    }

    TreePath recursePath = new TreePath(loc, eltname);

    if (c1 == null || c2 == null || !c1.equals(c2)) {
      throw new DeepInequalityException(eltname + " miscompared", recursePath);
    }
  }
776184
@Override
    public IPromise then(Callback resultCB) {
        // FIXME: this can be implemented more efficient
        while( !lock.compareAndSet(false,true) ) {}
        try {
            if (resultReceiver != null)
                throw new RuntimeException("Double register of promise listener");
            resultReceiver = resultCB;
            if (hadResult) {
                hasFired = true;
                if (nextFuture == null) {
                    nextFuture = new Promise(result, error);
                    lock.set(false);
                    resultCB.complete(result, error);
                } else {
                    lock.set(false);
                    resultCB.complete(result, error);
                    nextFuture.complete(result, error);
                    return nextFuture;
                }
            }
            if (resultCB instanceof IPromise) {
                return (IPromise) resultCB;
            }
            lock.set(false);
            while( !lock.compareAndSet(false,true) ) {}
            if (nextFuture == null) {
                return nextFuture = new Promise();
            } else {
                return nextFuture;
            }
        } finally {
            lock.set(false);
        }
    }
58385
function combine(type) {
  for (var _len = arguments.length, atoms = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    atoms[_key - 1] = arguments[_key];
  }

  if (typeof type !== 'string') {
    var firstAtom = type;
    atoms = [firstAtom].concat(_toConsumableArray(atoms));
    type = firstAtom.type;
  }

  var actionParams = [];
  atoms.forEach(function (atom) {
    if (atom.isMutable) {
      actionParams.push.apply(actionParams, _toConsumableArray(atom.actionParams));
    }
  });
  if (checkDuplicateParams(actionParams)) {
    throw 'Duplicate parameters when combining atoms';
  }

  var getNewState = function getNewState(state, action) {
    var newState = {};
    atoms.forEach(function (atom) {
      if (atom.isMutable) {
        var data = {};
        atom.actionParams.forEach(function (param) {
          data[param] = action[param];
        });
        newState = _extends({}, newState, atom.getNewState(state, data));
      } else {
        newState = _extends({}, newState, atom.getNewState());
      }
    });
    return newState;
  };

  return (0, _createAtom2.default)({
    isMutable: atoms.findIndex(function (atom) {
      return atom.isMutable;
    }) >= 0,
    type: type,
    actionParams: actionParams,
    getNewState: getNewState
  });
}
850619
function(type, data){
            var listeners = _cache[type],len = 0;
            if(!$.isUndefined(listeners)){
                var args = [].slice.call(arguments, 0);
                args = args.length > 2 ? args.splice(2, args.length-1) : [];
                args = [data].concat(args);

                len = listeners.length;
                for(var i = 0; i<len;i++){
                    var listener = listeners[i];
                    if(listener && listener.callback) {
                        args = args.concat(listener.args);
                        listener.callback.apply(listener.scope, args);
                    }
                }
            }
            return this;
        }
315518
public Atom rewriteWithTypeVariable(Atom parentAtom) {
        if (parentAtom.getPredicateVariable().isReturned()
                && !this.getPredicateVariable().isReturned()
                && this.getClass() == parentAtom.getClass()) {
            return rewriteWithTypeVariable();
        }
        return this;
    }
192045
@Override
    public void write(IChemObject object) throws UnsupportedChemObjectException {
        if (object instanceof ICrystal) {
            writeCrystal((ICrystal) object);
        } else if (object instanceof IChemSequence) {
            writeChemSequence((IChemSequence) object);
        } else {
            throw new UnsupportedChemObjectException("This object type is not supported.");
        }
    }
346221
void processSpecialNodeTypes(NodeWithType<?, Type> node, String name) {
        Type type = node.getType();
        if ("buffer".equals(name) && isRefArray(type, "E")) {
            node.setType(atomicRefArrayType((ArrayType) type));
        } else if ("sBuffer".equals(name) && isLongArray(type)) {
            node.setType(atomicLongArrayType());
        } else if (PrimitiveType.longType().equals(type)) {
            switch(name) {
            case "mask":
            case "offset":
            case "seqOffset":
            case "lookAheadSeqOffset":
            case "lookAheadElementOffset":
                node.setType(PrimitiveType.intType());
            }
        }
    }
1243108
private void assign(final Object val,
                             final Element el,
                             final Collection<Object> col,
                             final Object o,
                             final Method meth) throws Throwable {
    if (col != null) {
      col.add(val);
    } else if (!cb.save(el, o, val)) {
      final Object[] pars = new Object[]{val};

      meth.invoke(o, pars);
    }
  }
193521
function processObjectType(object: GraphQLObjectType) {
  return reduce(
    object._typeConfig,
    (def, value, key) => {
      return setDef(
        def,
        key,
        value,
        [
          'description',
          'interfaces',
          'fields',
          'isTypeOf',
          'astNode',
          'onConflict',
        ],
        object,
      );
    },
    { type: 'Object' },
    true,
  );
}
66281
function IPromise(executor) {
  const self = this;
  if (!Shared.isObject(self)) {
    throw new TypeError('IPromise must be a object');
  }
  if (!Shared.isFunction(executor)) {
    throw new TypeError('executor must be a function');
  }
  this.currentState = Shared.PENDING; // default
  this.valOrErr = null; // if fulfilled result to it else rejected error to it
  this.onFulfilledCallback = []; // if current state PENDING push the func wait onFulfilled to exec
  this.onRejectedCallback = []; // if current state PENDING push the func wait onRejected to exec

  // safely executor when executor not a empty function
  if (Shared.noop !== executor) {
    safelyToExecutor(self, executor);
  }
}
31706
def to_atomic(self):
        
        lower = self._intervals[0].lower
        left = self._intervals[0].left
        upper = self._intervals[-1].upper
        right = self._intervals[-1].right

        return AtomicInterval(left, lower, upper, right)
562867
function emitObject() {
      var item = {
        type: types[type],
        size: length,
        body: bops.join(parts),
        offset: start
      };
      if (ref) item.ref = ref;
      parts.length = 0;
      start = 0;
      offset = 0;
      type = 0;
      length = 0;
      ref = null;
      emit(item);
    }
1260251
@Pure
	@Inline(value = "new $2($1.intValue())", imported = AtomicInteger.class)
	public static AtomicInteger toAtomicInteger(AtomicDouble number) {
		return new AtomicInteger(number.intValue());
	}
665977
function observeObject(o, observer) {
  return o && typeof o === 'object' && observe(o, observer, observer.keys);
}
5125
function observeOnce(object, observer, types) {
  function _observer(changes) {
    observer(changes);
    unobserve(object, _observer);
  }
  observe(object, _observer, types);
}
1006741
function init (Jud) {
  const Atomic = Jud.Atomic
  const extend = Jud.utils.extend
  getRgb = Jud.utils.getRgb
  loopArray = Jud.utils.loopArray

  function Spinner (data) {
    Atomic.call(this, data)
  }
  Spinner.prototype = Object.create(Atomic.prototype)
  extend(Spinner.prototype, proto)
  extend(Spinner.prototype, {
    style: extend(Object.create(Atomic.prototype.style), style)
  })

  Jud.registerComponent('spinner', Spinner)
  Jud.registerComponent('loading-indicator', Spinner)
}
672970
@Pure
	@Inline(value = "new $2($1.longValue())", imported = AtomicLong.class)
	public static AtomicLong toAtomicLong(AtomicDouble number) {
		return new AtomicLong(number.longValue());
	}