JetBundle.properties

#quick fix messages
add.function.body=Add function body
change.to.constructor.invocation=Change to constructor invocation
add.return.type=Add return type declaration
change.accessor.type=Change accessor type
change.getter.type=Change getter type to {0}
change.setter.type=Change setter parameter type to {0}
make.variable.immutable=Make variable immutable
make.variable.mutable=Make variable mutable
change.variable.mutability.family=Change Variable Mutability
remove.function.body=Remove function body
make.element.modifier=Make {0} {1}
add.modifier=Add ''{0}'' modifier
add.modifier.family=Add Modifier
add.init.keyword=Add 'init' keyword
add.init.keyword.family=Add 'init' keyword
add.init.keyword.in.whole.project=Add 'init' keyword in whole project
add.init.keyword.in.whole.project.modal.title=Adding 'init' keyword in whole project
add.init.keyword.in.whole.project.family=Add 'init' keyword in whole project
insert.delegation.call=Insert ''{0}()'' call
make.element.in.classifiers.open=Make ''{0}'' in {1} open
make.class.annotation.class=Make ''{0}'' an annotation class
make.class.annotation.class.family=Make Class an Annotation Class
add.star.projections=Add ''{0}''
change.to.star.projection=Change type arguments to {0}
change.to.star.projection.family=Change to Star Projection
make.element.not.modifier=Make {0} not {1}
remove.modifier=Remove ''{0}'' modifier
remove.modifier.family=Remove Modifier
remove.redundant.modifier=Remove redundant ''{0}'' modifier
remove.parts.from.property=Remove {0} from property
remove.parts.from.property.family=Remove Parts from Property
remove.psi.element.family=Remove Element
remove.right.part.of.binary.expression=Remove right part of a binary expression
remove.cast=Remove cast
remove.elvis.operator=Remove elvis operator
remove.redundant.nullable=Remove redundant '?'
remove.supertype=Remove supertype ''{0}''
remove.supertype.family=Remove supertype
remove.supertype.nullable=Remove '?'
remove.type.arguments=Remove type arguments
remove.useless.nullable=Remove useless '?'
remove.nullable.family=Remove '?'
remove.spread.sign=Remove '*'
remove.conflicting.import=Remove conflicting import for ''{0}''
remove.conflicting.import.family=Remove Conflicting Import
replace.operation.in.binary.expression=Replace operation in a binary expression
replace.cast.with.static.assert=Replace a cast with a static assert
replace.with.dot.call=Replace with dot call
replace.with.safe.call=Replace with safe (?.) call
introduce.non.null.assertion=Add non-null asserted (!!) call
remove.unnecessary.non.null.assertion=Remove unnecessary non-null assertion (!!)
change.to.backing.field=Change reference to backing field
implement.members=Implement members
new.kotlin.file.action=Kotlin File
import.fix=Import
imports.chooser.title=Imports
specify.type.explicitly.action.family.name=Specify Type Explicitly
specify.type.explicitly.add.return.type.action.name=Specify return type explicitly
specify.type.explicitly.add.action.name=Specify type explicitly
specify.type.explicitly.remove.action.name=Remove explicitly specified type
rename.parameter.to.match.overridden.method=Rename parameter to match overridden method
rename.family=Rename
rename.kotlin.package.class.error="Can't rename kotlin package class"
add.semicolon.after.invocation=Add semicolon after invocation of ''{0}''
add.semicolon.family=Add Semicolon
change.function.return.type=Change ''{0}'' function return type to ''{1}''
change.no.name.function.return.type=Change function return type to ''{0}''
change.function.literal.return.type=Change function literal return type to ''{0}''
remove.function.return.type=Remove explicitly specified return type in ''{0}'' function
remove.no.name.function.return.type=Remove explicitly specified function return type
change.element.type=Change ''{0}'' type to ''{1}''
change.function.parameter.type=Change parameter ''{0}'' type of function ''{1}'' to ''{2}''
change.primary.constructor.parameter.type=Change parameter ''{0}'' type of primary constructor of class ''{1}'' to ''{2}''
change.type=Change type from ''{0}'' to ''{1}''
change.type.family=Change Type
add.parameters.to.function=Add parameter{0} to function ''{1}''
add.parameters.to.constructor=Add parameter{0} to constructor ''{1}''
change.function.signature=Change the signature of function ''{0}''
change.constructor.signature=Change the signature of constructor ''{0}''
change.function.literal.signature=Change the signature of function literal
remove.parameter=Remove parameter ''{0}''
change.signature.family=Change signature of function/constructor
cast.expression.to.type=Cast expression ''{0}'' to ''{1}''
cast.expression.family=Cast Expression
simplify.negated.binary.expression=Simplify negated ''{0}'' expression to ''{1}''
simplify.negated.binary.expression.family=Simplify Negated Binary Expression

replace.call.error.skipped.defaults=Cannot skip default arguments.
replace.call.error.undefined.returntype=Unable to determine the return type.
replace.call.error.duplicate.or.missing.arguments=Duplicate or missing arguments.
replace.call.error.invalid.arguments=Invalid arguments included.

replace.call.error.vararg.not.last=Cannot handle named arguments after a vararg.
replace.call.error.contains.returns_boolean=Contains must return a Boolean.

replace.get.with.index=Replace 'get' call with index operator
replace.get.with.index.family=Replace Get

replace.contains.with.in=Replace 'contains' call with in operator
replace.contains.with.in.family=Replace Contains

replace.invoke.with.call=Replace 'invoke' with direct call
replace.invoke.with.call.family=Replace Invoke

replace.unary.operator.with.prefix=Replace with ''{0}'' prefix
replace.unary.operator.with.prefix.family=Replace Unary Operator

replace.binary.operator.with.infix=Replace with ''{0}'' operator
replace.binary.operator.with.infix.family=Replace Binary Operator


add.kotlin.signature.action.family.name=Specify Custom Kotlin Signature
add.kotlin.signature.action.text=Specify custom Kotlin signature
edit.kotlin.signature.action.text=Edit custom Kotlin signature
view.kotlin.signature.action.text=View custom Kotlin signature

goto.super.function.chooser.title=Choose super function
goto.super.property.chooser.title=Choose super property
goto.super.class.chooser.title=Choose super class or interface

unused.class=Class ''{0}'' is never used
unused.object=Object ''{0}'' is never used
unused.function=Function ''{0}'' is never used
unused.property=Property ''{0}'' is never used
unused.type.parameter=Type parameter ''{0}'' is never used

unused.receiver.parameter=Receiver parameter is never used
unused.receiver.parameter.remove=Remove redundant receiver parameter

livetemplate.description.main=main() function
livetemplate.description.soutp=Prints function parameter names and values to System.out
livetemplate.description.iter=Iterate over elements of iterable (for-in loop)
livetemplate.description.ifn=Inserts ''if null'' expression
livetemplate.description.inn=Inserts ''if not null'' expression
livetemplate.description.void=Function returning nothing
livetemplate.description.fun0=Function with no parameters
livetemplate.description.fun1=Function with one parameter
livetemplate.description.fun2=Function with two parameters
livetemplate.description.interface=Trait
livetemplate.description.singleton=Singleton
livetemplate.description.closure=Closure (function without name)
livetemplate.description.anonymous=Anonymous class
livetemplate.description.exfun=Extension function
livetemplate.description.exval=Extension read-only property
livetemplate.description.exvar=Extension read-write property
macro.variable.of.type=kotlinVariable()
macro.iterable.variable=kotlinIterableVariable()
macro.suggest.variable.name=kotlinSuggestVariableName()
macro.fun.parameters=functionParameters()
macro.fun.anonymousSuper=anonymousSuper()
change.visibility.modifier=Change visibility modifier

options.kotlin.attribute.descriptor.builtin.annotation=Built-in annotation
options.kotlin.attribute.descriptor.string.escape=Escape in string and template braces
options.kotlin.attribute.descriptor.closure.braces=Function literal braces and arrow
options.kotlin.attribute.descriptor.safe.access=Safe access dot
options.kotlin.attribute.descriptor.arrow=Arrow
options.kotlin.attribute.descriptor.kdoc.comment=KDoc comment
options.kotlin.attribute.descriptor.kdoc.tag=KDoc tag
options.kotlin.attribute.descriptor.kdoc.value=Link in KDoc tag
options.kotlin.attribute.descriptor.trait=Trait
options.kotlin.attribute.descriptor.object=Object
options.kotlin.attribute.descriptor.annotation=Annotation
options.kotlin.attribute.descriptor.var=Var (mutable variable, parameter or property)
options.kotlin.attribute.descriptor.local.variable=Local variable or value
options.kotlin.attribute.descriptor.captured.variable=Variables and values captured in a closure
options.kotlin.attribute.descriptor.instance.property=Instance property
options.kotlin.attribute.descriptor.package.property=Package-level property
options.kotlin.attribute.descriptor.property.with.backing=Property with backing field
options.kotlin.attribute.descriptor.backing.field.access=Backing field access
options.kotlin.attribute.descriptor.extension.property=Extension property
options.kotlin.attribute.descriptor.dynamic.property=Dynamic property
options.kotlin.attribute.descriptor.it=Function literal default parameter
options.kotlin.attribute.descriptor.fun=Function declaration
options.kotlin.attribute.descriptor.fun.call=Function call
options.kotlin.attribute.descriptor.dynamic.fun.call=Dynamic function call
options.kotlin.attribute.descriptor.package.fun.call=Package-level function call
options.kotlin.attribute.descriptor.extension.fun.call=Extension function call
options.kotlin.attribute.descriptor.constructor.call=Constructor call
options.kotlin.attribute.descriptor.variable.as.function.call=Variable as function call
options.kotlin.attribute.descriptor.variable.as.function.like.call=Variable as function-like call
options.kotlin.attribute.descriptor.smart.cast=Smart-cast value
options.kotlin.attribute.descriptor.label=Label
change.to.function.invocation=Change to function invocation
migrate.sure=Replace sure() calls by !! in project
migrate.class.object.to.companion=Replace 'class' keyword with 'companion' modifier
migrate.class.object.to.companion.family=Replace 'class' Keyword with 'companion' Modifier
migrate.class.object.to.companion.in.whole.project=Replace 'class' keyword with 'companion' modifier in whole project
migrate.class.object.to.companion.in.whole.project.modal.title=Replacing 'class' keyword with 'companion' modifier in whole project
migrate.class.object.to.companion.in.whole.project.family=Replace 'class' Keyword with 'companion' Modifier in Whole Project
migrate.lambda.syntax=Migrate lambda syntax
migrate.lambda.syntax.family=Migrate lambda syntax
migrate.lambda.syntax.in.whole.project=Migrate lambda syntax in whole project
migrate.lambda.syntax.in.whole.project.modal.title=Migrating lambda syntax in whole project
migrate.lambda.syntax.in.whole.project.family=Migrate lambda syntax in whole project
remove.val.var.from.parameter=Remove ''{0}'' from parameter
add.override.to.equals.hashCode.toString=Add 'override' to equals, hashCode, toString in project
add.when.else.branch.action.family.name=Add Else Branch
add.when.else.branch.action=Add else branch
move.when.else.branch.to.the.end.action=Move else branch to the end
move.when.else.branch.to.the.end.family.name=Move Else Branch to the End
change.to.property.name.family.name=Change to property name
change.to.property.name.action=Change ''{0}'' to ''{1}''
map.platform.class.to.kotlin=Change all usages of ''{0}'' in this file to ''{1}''
map.platform.class.to.kotlin.multiple=Change all usages of ''{0}'' in this file to a Kotlin class
map.platform.class.to.kotlin.advertisement=Choose an appropriate Kotlin class
map.platform.class.to.kotlin.family=Change to Kotlin class
create.from.usage.family=Create from usage
create.0.from.usage=Create {0}
create.local.variable.from.usage=Create local variable ''{0}''
create.parameter.from.usage=Create parameter ''{0}''
choose.target.class.or.trait.title=Choose target class or trait
surround.with=Surround with
surround.with.string.template="${expr}"
surround.with.when.template=when (expr) {}
surround.with.runtime.type.cast.template=(expr as RuntimeType)
surround.with.function.template={ }
surround.with.cannot.perform.action=Cannot perform Surround With action to the current contextsurround.with.function.template={ }
remove.variable.family.name=Remove variable
remove.variable.action=Remove variable ''{0}''
kotlin.code.transformations=Kotlin Code Transformations
fold.if.to.assignment=Replace 'if' expression with assignment
fold.if.to.assignment.family=Replace 'if' Expression with Assignment
fold.if.to.return=Replace 'if' expression with return
fold.if.to.return.family=Replace 'if' Expression with Return
fold.if.to.call=Replace 'if' expression with method call
fold.if.to.call.family=Replace 'if' Expression with Method Call
fold.when.to.assignment=Replace 'when' expression with assignment
fold.when.to.assignment.family=Replace 'when' Expression with Assignment
fold.when.to.return=Replace 'when' expression with return
fold.when.to.return.family=Replace 'when' Expression with Return
fold.when.to.call=Replace 'when' expression with method call
fold.when.to.call.family=Replace 'when' Expression with Method Call
unfold.assignment.to.if=Replace assignment with 'if' expression
unfold.assignment.to.if.family=Replace Assignment with 'if' Expression
unfold.property.to.if=Replace property initializer with 'if' expression
unfold.property.to.if.family=Replace Property Initializer with 'if' Expression
unfold.return.to.if=Replace return with 'if' expression
unfold.return.to.if.family=Replace Return with 'if' Expression
unfold.call.to.if=Replace method call with 'if' expression
unfold.call.to.if.family=Replace Method Call with 'if' Expression
unfold.assignment.to.when=Replace assignment with 'when' expression
unfold.assignment.to.when.family=Replace Assignment with 'when' Expression
unfold.property.to.when=Replace property initializer with 'when' expression
unfold.property.to.when.family=Replace Property Initializer with 'when' Expression
unfold.return.to.when=Replace return with 'when' expression
unfold.return.to.when.family=Replace Return with 'when' Expression
unfold.call.to.when=Replace method call with 'when' expression
unfold.call.to.when.family=Replace Method Call with 'when' Expression
double.bang.to.if.then.exception.text=Expression ''{0}'' must not be null
double.bang.to.if.then.choose.exception=Choose Exception Class
double.bang.to.if.then=Replace '!!' expression with 'if' expression
double.bang.to.if.then.family=Replace '!!' Expression with 'if' Expression
if.then.to.double.bang=Replace 'if' expression with '!!' expression
if.then.to.double.bang.replace.exception=Replace 'if' expression with '!!' expression (will remove Exception)
if.then.to.double.bang.family=Replace 'if' Expression with '!!' Expression
elvis.to.if.then=Replace elvis expression with 'if' expression
elvis.to.if.then.family=Replace Elvis Expression with 'if' Expression
if.then.to.elvis=Replace 'if' expression with elvis expression
if.then.to.elvis.family=Replace 'if' Expression with Elvis Expression
safe.access.to.if.then=Replace safe access expression with 'if' expression
safe.access.to.if.then.family=Replace Safe Access Expression with 'if' Expression
if.then.to.safe.access=Replace 'if' expression with safe access expression
if.then.to.safe.access.family=Replace 'if' Expression with Safe Access Expression
if.to.when=Replace 'if' with 'when'
if.to.when.family=Replace 'if' with 'when'
when.to.if=Replace 'when' with 'if'
when.to.if.family=Replace 'when' with 'if'
flatten.when=Flatten 'when' expression
flatten.when.family=Flatten 'when' Expression
merge.when=Merge 'when' expressions
merge.when.family=Merge 'when' Expression
introduce.when.subject=Introduce argument to 'when'
introduce.when.subject.family=Introduce Argument to 'when'
eliminate.when.subject=Eliminate argument of 'when'
eliminate.when.subject.family=Eliminate Argument of 'when'
transform.if.statement.with.assignments.to.expression=Transform 'if' statement with assignments to expression
transform.assignment.with.if.expression.to.statement=Transform assignment with 'if' expression to statement
transform.if.statement.with.assignments.to.expression.family=Transform 'if' Statement with Assignments to Expression
transform.assignment.with.if.expression.to.statement.family=Transform Assignment with 'if' Expression to Statement
split.property.declaration=Split property declaration
split.property.declaration.family=Split Property Declaration
change.function.signature.action.single=Change function signature to ''{0}''
change.function.signature.action.multiple=Change function signature...
change.function.signature.family=Change function signature
change.function.signature.chooser.title=Choose signature
change.function.signature.action=Change function signature
remove.unnecessary.parentheses=Remove unnecessary parentheses
remove.unnecessary.parentheses.family=Remove Unnecessary Parentheses
remove.unnecessary.curly.brackets.from.string.template=Remove curly braces from variable
remove.unnecessary.curly.brackets.from.string.template.family=Remove Curly Braces From Variable
insert.curly.brackets.to.string.template=Insert curly braces around variable
insert.curly.brackets.to.string.template.family=Insert Curly Braces Around Variable
add.name.to.argument.family=Add Name to Argument
add.name.to.argument.single=Add name to argument\: ''{0}''
add.name.to.argument.multiple=Add name to argument...
add.name.to.argument.action=Add name to argument...
add.name.to.parameter.name.chooser.title=Choose parameter name
replace.with.dot.qualified.method.call.intention=Replace with simple method call
replace.with.dot.qualified.method.call.intention.family=Replace with Simple Method Call
replace.with.infix.function.call.intention=Replace with infix function call
replace.with.infix.function.call.intention.family=Replace with Infix Function Call
replace.with.infix.function.call.intention.error.resolution.failed=The element cannot be resolved
replace.with.infix.function.call.intention.error.package.call=Cannot be applied with a package as the receiver
replace.explicit.function.literal.param.with.it=Replace explicit parameter ''{0}'' with ''it''
replace.explicit.function.literal.param.with.it.family=Replace Explicit Parameter with 'it'
move.lambda.inside.parentheses=Move lambda function into parentheses
move.lambda.inside.parentheses.family=Move Lambda Function Into Parentheses
move.lambda.outside.parentheses=Move lambda expression out of parentheses
move.lambda.outside.parentheses.family=Move Lambda Expression out of Parentheses
replace.it.with.explicit.function.literal.param=Replace 'it' with explicit parameter
replace.it.with.explicit.function.literal.param.family=Replace 'it' with Explicit Parameter
split.if=Split into 2 if's
split.if.family=Split If
replace.with.operator.assign.intention=Replace with an operator-assign expression
replace.with.operator.assign.intention.family=Replace with an Operator-Assign Expression
replace.with.traditional.assignment.intention=Replace with traditional assignment
replace.with.traditional.assignment.intention.family=Replace with Traditional Assignment
simplify.boolean.with.constants=Simplify boolean expression
simplify.boolean.with.constants.family=Simplify Boolean Expression
insert.explicit.type.arguments=Add explicit type arguments
insert.explicit.type.arguments.family=Add Explicit Type Arguments
remove.explicit.type.arguments=Remove explicit type arguments
remove.explicit.type.arguments.family=Remove Explicit Type Arguments
convert.if.with.throw.to.assert=Replace 'if' with 'assert' statement
convert.if.with.throw.to.assert.family=Replace 'if' with 'assert' Statement
make.type.explicit.in.lambda=Make types explicit in lambda
make.type.explicit.in.lambda.family=Make Types Explicit In Lambda
make.type.implicit.in.lambda=Make types implicit in lambda (may break code)
make.type.implicit.in.lambda.family=Make Types Implicit In Lambda (May Break Code)
invert.if.condition=Invert If Condition
invert.if.condition.family=Invert If Condition
convert.to.for.each.loop.intention=Replace with a for each loop
convert.to.for.each.loop.intention.family=Replace with a For Each Loop
convert.to.string.template=Convert concatenation to template
convert.to.string.template.family=Convert Concatenation to Template

property.is.implemented.too.many=Has implementations
property.is.overridden.too.many=Is overridden in subclasses
property.is.implemented.header=Is implemented in <br/>
property.is.overridden.header=Is overridden in <br/>

navigation.title.overriding.property=Choose Implementation of {0}
navigation.findUsages.title.overriding.property=Overriding properties of {0}
navigation.title.super.declaration=Choose Super Implementation of {0}
navigation.findUsages.title.super.declaration=Super Implementations of {0}

add.function.to.supertype.family=Add Function to Supertype
add.function.to.supertype.action.multiple=Add function to supertype...
add.function.to.type.action.single=Add ''{0}'' to ''{1}''
add.function.to.type.action=Add function to type
add.function.to.type.action.type.chooser=Choose type...

remove.expression = Remove ''{0}''
unwrap.expression = Unwrap ''{0}''
remove.else = Remove else in ''{0}''
unwrap.else = Unwrap else in ''{0}''

usageType.annotation.type = Annotation
usageType.import = Import directive
usageType.callable.reference = Callable reference
usageType.type.constraint = Type constraint
usageType.type.argument = Type argument
usageType.value.parameter.type = Parameter type
usageType.nonLocal.property.type = Class/object property type
usageType.local.variable.type = Local variable type
usageType.function.return.type = Function return types
usageType.superType = Supertype
usageType.type.definition = Type definition
usageType.is = Target type of 'is' operation
usageType.as = Target type of 'as' operation
usageType.class.object = Nested class/object
usageType.companion.object = Companion object
usageType.instantiation = Instantiation
usageType.function.call = Function call
usageType.implicit.get = Implicit 'get'
usageType.implicit.set = Implicit 'set'
usageType.implicit.invoke = Implicit 'invoke'
usageType.implicit.iteration = Implicit iteration
usageType.property.delegation = Property delegation
usageType.extension.receiver.type = Extension receiver type
usageType.super.type.qualifier = Super type qualifier
usageType.receiver = Receiver
usageType.selector = Selector
usageType.delegate = Delegate
usageType.packageDirective = Package directive
usageType.packageMemberAccess = Package member access

x.in.y={0} in {1}
x.implements.y={0} in {1} implements {2} in {3}.
x.overrides.y.in.class.list={0} in {1} overrides functions in the following classes/traits: {2} Do you want to {3} the base functions?

unused.overriding.methods.title=Unused Overriding Members
there.are.unused.methods.that.override.methods.you.delete=There are unused members that override methods you delete.
choose.the.ones.you.want.to.be.deleted=Choose the ones you want to be deleted.
method.column=Member
delete.param.in.method.hierarchy={0} is a part of method hierarchy. Do you want to delete multiple parameters?
super.methods.delete.with.usage.search=delete (with usage search)
super.methods.action.key.find.usages=find usages of

find.what.implementing.methods.checkbox=&Implementing functions
find.what.overriding.methods.checkbox=Over&riding functions
find.what.implementing.properties.checkbox=&Implementing properties
find.what.overriding.properties.checkbox=Over&riding properties
find.what.property.readers.checkbox=Readers
find.what.property.writers.checkbox=Writers
find.options.include.overloaded.methods.checkbox=Include o&verloaded functions and extensions
find.what.functions.usages.checkbox=Usages of &functions
find.what.properties.usages.checkbox=Usages of &properties
find.what.constructor.usages.checkbox=Usages of &constructor
find.what.derived.traits.checkbox=&Derived traits
find.what.derived.classes.checkbox=&Derived classes

hierarchy.legend.member.is.defined.in.class=Member is defined in the class
hierarchy.legend.member.defined.in.superclass=Member is not defined in the class but defined in superclass
hierarchy.legend.member.should.be.defined=Member should be defined since the class is not abstract

convert.to.extension=Convert to extension
replace.by.reconstructed.type.family.name=Replace by Reconstructed Type
replace.by.reconstructed.type=Replace by ''{0}''

suppress.warnings.family=Suppress Warnings
suppress.warning.for=Suppress ''{0}'' for {1} {2}

reflection.not.found=Reflection not found in the classpath
add.reflection.to.classpath=Add kotlin-reflect.jar to the classpath

# Kotlin Compiler Settings Tab

#Common
kotlin.compiler.option.generate.no.warnings=Generate no &warnings
kotlin.compiler.option.additional.command.line.parameters=&Additional command line parameters:
kotlin.compiler.option.additional.command.line.parameters.dialog.title=Additional command line parameters

# Kotlin to JVM
kotlin.compiler.jvm.option.panel.title=Kotlin to JVM

# Kotlin to JavaScript
kotlin.compiler.js.option.panel.title=Kotlin to JavaScript
kotlin.compiler.js.option.generate.sourcemaps=Generate &source maps
kotlin.compiler.js.option.output.prefix=Output file &prefix:
kotlin.compiler.js.option.output.postfix=Output file p&ostfix:
kotlin.compiler.js.option.output.prefix.browse.title=Choose output file prefix
kotlin.compiler.js.option.output.postfix.browse.title=Choose output file postfix
kotlin.compiler.js.option.output.copy.files=&Copy library runtime files
kotlin.compiler.js.option.output.copy.dir=O&utput directory for library &runtime files:

# Debugger
debugger.filter.ignore.internal.classes=Do not step into specific Kotlin classes
debugger.data.view.delegated.properties=Calculate values of delegated properties (may affect program execution)