Emotions

Download from [GitHub](https://github.com/BrainbitLLC/EmotionsStateArtifacts-cpp) all folders and add .dll to your project by your preferred way.
            

#### First way

1. Download `libem_st_artifacts.deb` from [GitHub](https://github.com/BrainbitLLC/linux_em_st_artifacts/tree/main/package).
2. Install package by `apt`:

```
sudo apt install ./libem_st_artifacts.deb
```

#### Second way

Download from [GitHub](https://github.com/BrainbitLLC/linux_em_st_artifacts/tree/main/raw) and add .so to your project by your preferred way.

Library built on Astra Linux CE 2.12.46, kernel 5.15.0-70-generic. Arch: x86_64 GNU/Linux

```
user@astra:~$ ldd --version
ldd (Debian GLIBC 2.28-10+deb10u1) 2.28
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Written by Roland McGrath and Ulrich Drepper.
```

That library depends from others library, for instance:
```
linux-vdso.so.1
libblkid.so.1
libc++.so.1
libc++abi.so.1 
libc.so.6
libdl.so.2
libffi.so.6
libgcc_s.so.1
libgio-2.0.so.0
libglib-2.0.so.0
libgmodule-2.0.so.0
libgobject-2.0.so.0
libm.so.6
libmount.so.1
libpcre.so.3
libpthread.so.0
libresolv.so.2 
librt.so.1
libselinux.so.1
libstdc++.so.6
libudev.so.1
libuuid.so.1
libz.so.1
ld-linux-x86-64.so.2
```

If you are using a OS other than ours, these dependencies will be required for the library. You can download dependencies from [here](https://github.com/BrainbitLLC/linux_neurosdk2/tree/main/dependencies).
            

The Android version is designed for APIs >= 21.

Neurosdk for android is distributed using JitPack as an aar library. Here is an example of adding SDK to an AndroidStudio project using gradle:

Add to `build.gradle` of project:

###### Groovy:
```groovy
dependencyResolutionManagement {
	repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
	repositories {
		...
		maven { url 'https://jitpack.io' }
	}
}
```

###### Kotlin:
```kotlin
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        ...
        maven { setUrl("https://jitpack.io") }
    }
}
```

and to `build.gradle` of app:

###### Groovy:
```groovy
dependencies {
    implementation 'com.github.BrainbitLLC:Emotional-state-artifacts:1.0.1'
}
```

###### Kotlin:
```kotlin
dependencies {
    implementation("com.github.BrainbitLLC:Emotional-state-artifacts:1.0.1")
}
```

To prevent build errors add to build.gradle this settings:

###### Groovy:
```groovy
android {
    packagingOptions {
        pickFirst 'lib/x86_64/libc++_shared.so'
        pickFirst 'lib/x86/libc++_shared.so'
        pickFirst 'lib/arm64-v8a/libc++_shared.so'
        pickFirst 'lib/armeabi-v7a/libc++_shared.so'
    }
    ...
}
```

Latest version: `1.0.1`
            

The iOS version is designed for OS >= 12.0.

By Pods:

Add to Podspec file:

```
pod 'em-st-artifacts', '1.0.2'
```

And run `pod install` command.

You can install framework manually:

1. download `em-st-artifacts.xcframework` from [GitHub](https://github.com/BrainbitLLC/apple_em-st-artifacts)
2. add `em-st-artifacts.xcframework` to `Frameworks, Libraries, and Embedded Content` section of your project
3. set `Embedded` to `Embed & Sign`

Latest version: `1.0.2`
            

> Python package available for Windows, MacOS and Astra Linux

By pip:

```
pip install pyem-st-artifacts
```

Before you can use the library on linux, you must install the emotion library:
```
sudo apt install ./libem_st_artifacts.deb
```
It can be downloaded [here](https://github.com/BrainbitLLC/linux_em_st_artifacts/tree/main/package).


The package has the following structure:
 - em_st_artifacts - the main package with the implementation of methods
 - sample - file `sample.py`, sample of usage library
 - libs - contain dll library files

EmotionalMath - one main module contains all methods of library

```python
from em_st_artifacts.emotional_math import EmotionalMath
```
Latest version: `1.0.4`
            

> Available for iOS, Android, Windows, MacOS platforms

1. Open Package Manager
2. Click "Add" menu and choose "Add package from GIT url...". A text box and an Add button appear.
3. Enter a https://github.com/BrainbitLLC/unity_em_st_artifacts.git in the text box and click Add.

If Unity was able to install the package successfully, the package now appears in the package list with the  tag. If Unity was not able to install the package, the Unity Console displays an error message.

Latest version: `1.0.0`
            

> Available for iOS, Android and UWP platforms

Install latest version `EmStArtifacts` package from NuGet Gallery in your preferred way to a common project.

[NugetPackage](https://www.nuget.org/packages/EmStArtifacts)

Latest version: `1.0.6`
            

Install latest version `EmStArtifacts` package from NuGet Gallery in your preferred way.

Latest version: `1.0.6`

[NugetPackage](https://www.nuget.org/packages/EmStArtifacts)
            

MathLibSetting mathLibSetting;
mathLibSetting.sampling_rate = 250;
mathLibSetting.process_win_freq = 25;
mathLibSetting.n_first_sec_skipped = 4;
mathLibSetting.fft_window = 1000;
mathLibSetting.bipolar_mode = true;
mathLibSetting.channels_number = 4;
mathLibSetting.channel_for_analysis = 0;

ArtifactDetectSetting artifactDetectSetting;
artifactDetectSetting.art_bord = 110;
artifactDetectSetting.allowed_percent_artpoints = 70;
artifactDetectSetting.total_pow_border = 40 * 1e7;
artifactDetectSetting.raw_betap_limit = 800000;
artifactDetectSetting.spect_art_by_totalp = false;
artifactDetectSetting.global_artwin_sec = 4;
artifactDetectSetting.num_wins_for_quality_avg = 125;
artifactDetectSetting.hanning_win_spectrum = true;
artifactDetectSetting.hamming_win_spectrum = false;

ShortArtifactDetectSetting shortArtifactDetectSetting;
shortArtifactDetectSetting.ampl_art_detect_win_size = 200;
shortArtifactDetectSetting.ampl_art_zerod_area = 200;
shortArtifactDetectSetting.ampl_art_extremum_border = 25;

MentalAndSpectralSetting mentalAndSpectralSetting;
mentalAndSpectralSetting.n_sec_for_averaging = 2;
mentalAndSpectralSetting.n_sec_for_instant_estimation = 4;

OpStatus opSt;
MathLib* tMathPtr = createMathLib(mathLibSetting, artifactDetectSetting, shortArtifactDetectSetting, mentalAndSpectralSetting, &opSt);
            

int samplingFrequency = 250;
var mls = new MathLibSetting
{
    sampling_rate        = samplingFrequency,
    process_win_freq     = 25,
    n_first_sec_skipped  = 4,
    fft_window           = samplingFrequency * 4,
    bipolar_mode         = true,
    channels_number      = 4,
    channel_for_analysis = 0
};

var ads = new ArtifactDetectSetting
{
    art_bord                  = 110,
    allowed_percent_artpoints = 70,
    raw_betap_limit           = 800_000,
    total_pow_border          = 40 * 1e7;
    global_artwin_sec         = 4,
    spect_art_by_totalp       = true,
    num_wins_for_quality_avg  = 125,
    hanning_win_spectrum      = false,
    hamming_win_spectrum      = true
};

var sads = new ShortArtifactDetectSetting 
{ 
    ampl_art_detect_win_size = 200, 
    ampl_art_zerod_area = 200, 
    ampl_art_extremum_border = 25 
};

var mss = new MentalAndSpectralSetting 
{ 
    n_sec_for_averaging = 2, 
    n_sec_for_instant_estimation = 4 
};

var math = new EegEmotionalMath(mls, ads, sads, mss);
            

int samplingFrequency = 250;
MathLibSetting mls = new MathLibSetting(samplingFrequency, 25, samplingFrequency * 4, 4, true, 4, 0);

ArtifactDetectSetting ads = new ArtifactDetectSetting(110, 70, 800000,(int) (40*1e7), 4, true, true,false,125);

ShortArtifactDetectSetting sads = new ShortArtifactDetectSetting(200,200,25);

MentalAndSpectralSetting mss = new MentalAndSpectralSetting(2,4);

EmotionalMath tMathPtr = new EmotionalMath(mls, ads, sads, mss);
            

mls = lib_settings.MathLibSetting(sampling_rate=250,
                                  process_win_freq=25,
										 
                                  n_first_sec_skipped=4,
                                  fft_window=1000,
                                  bipolar_mode=True,
                                  squared_spectrum=True,
                                  channels_number=4,
                                  channel_for_analysis=0)

ads = lib_settings.ArtifactDetectSetting(art_bord=110,
                                         allowed_percent_artpoints=70,
                                         raw_betap_limit=800_000,
                                         global_artwin_sec=4,
                                         num_wins_for_quality_avg=125,
                                         hamming_win_spectrum=True,
                                         hanning_win_spectrum=False,
                                         total_pow_border=400_000_000,
                                         spect_art_by_totalp=True)

sads = lib_settings.ShortArtifactDetectSetting(ampl_art_detect_win_size=200,
                                               ampl_art_zerod_area=200,
                                               ampl_art_extremum_border=25)

mss = lib_settings.MentalAndSpectralSetting(n_sec_for_averaging=2,
                                            n_sec_for_instant_estimation=4)

math = EmotionalMath(mls, ads, sads, mss)
            

let mathLibSetting = EMMathLibSetting(samplingRate: 250,
                                      andProcessWinFreq: 25,
                                      andFftWindow: 1000,
                                      andNFirstSecSkipped: 4,
                                      andBipolarMode: true,
                                      andSquaredSpectrum: true,
                                      andChannelsNumber: 1,
                                      andChannelForAnalysis: 0)

let artifactDetectSetting = EMArtifactDetectSetting(artBord: 110,
                                                    andAllowedPercentArtpoints: 70,
                                                    andRawBetapLimit: 800000,
                                                    andTotalPowBorder: 80000000,
                                                    andGlobalArtwinSec: 4,
                                                    andSpectArtByTotalp: true,
                                                    andHanningWinSpectrum: false,
                                                    andHammingWinSpectrum: true,
                                                    andNumWinsForQualityAvg: 125)

let shortArtifactDetectSetting = ShortArtifactDetectSetting(ampl_art_detect_win_size: 200,
                                                            ampl_art_zerod_area: 200,
                                                            ampl_art_extremum_border: 25)

let mentalAndSpectralSetting = MentalAndSpectralSetting(n_sec_for_instant_estimation: 4,
                                                                    n_sec_for_averaging: 2)
                                                                    
let emotionalMath = EMEmotionalMath(libSettings: mathLibSetting, andArtifactDetetectSettings: artifactDetectSetting, andShortArtifactDetectSettigns: shortArtifactDetectSetting, andMentalAndSpectralSettings: mentalAndSpectralSetting)
            

EMMathLibSetting* mathLibSetting = [[EMMathLibSetting alloc] initWithSamplingRate:250
                                                                andProcessWinFreq:25
                                                                     andFftWindow:1000
                                                              andNFirstSecSkipped:4
                                                                   andBipolarMode:true
                                                               andSquaredSpectrum:true
                                                                andChannelsNumber:1
                                                            andChannelForAnalysis:0];

EMArtifactDetectSetting* artifactDetectSetting = [[EMArtifactDetectSetting alloc] initWithArtBord:110
                                                                       andAllowedPercentArtpoints:70
                                                                                 andRawBetapLimit:800000
                                                                                andTotalPowBorder:80000000
                                                                               andGlobalArtwinSec:4
                                                                              andSpectArtByTotalp:true
                                                                            andHanningWinSpectrum:false
                                                                            andHammingWinSpectrum:true
                                                                          andNumWinsForQualityAvg:125];

ShortArtifactDetectSetting shortArtifactDetectSetting;
shortArtifactDetectSetting.ampl_art_detect_win_size = 200;
shortArtifactDetectSetting.ampl_art_zerod_area = 200;
shortArtifactDetectSetting.ampl_art_extremum_border = 25;

MentalAndSpectralSetting mentalAndSpectralSetting;
mentalAndSpectralSetting.n_sec_for_averaging = 2;
mentalAndSpectralSetting.n_sec_for_instant_estimation = 4;

EMEmotionalMath* math = [[EMEmotionalMath alloc] initWithLibSettings:mathLibSetting
                                         andArtifactDetetectSettings:artifactDetectSetting
                                      andShortArtifactDetectSettigns:shortArtifactDetectSetting
                                        andMentalAndSpectralSettings:mentalAndSpectralSetting];
            

OpStatus opSt;

// setting calibration length
int calibration_length = 6;
MathLibSetCallibrationLength(tMathPtr, calibration_length, &opSt);

// type of evaluation of instant mental levels
bool independent_mental_levels = false;
MathLibSetMentalEstimationMode(tMathPtr, independent_mental_levels, &opSt);

// number of windows after the artifact with the previous actual value
int nwins_skip_after_artifact = 10;
MathLibSetSkipWinsAfterArtifact(tMathPtr, nwins_skip_after_artifact, &opSt);

// calculation of mental levels relative to calibration values
MathLibSetZeroSpectWaves(tMathPtr, true, 0, 1, 1, 1, 0, &opSt);

// spectrum normalization by bandwidth
MathLibSetSpectNormalizationByBandsWidth(tMathPtr, true);
            

// setting calibration length
int calibrationLength = 6;
math.SetCallibrationLength(calibrationLength);

// type of evaluation of instant mental levels
bool independentMentalLevels = false;
math.SetMentalEstimationMode(independentMentalLevels);

// number of windows after the artifact with the previous actual value
int nwinsSkipAfterArtifact = 10;
math.SetSkipWinsAfterArtifact(nwinsSkipAfterArtifact);

// calculation of mental levels relative to calibration values
math.SetZeroSpectWaves(true, 0, 1, 1, 1, 0);

// spectrum normalization by bandwidth
math.SetSpectNormalizationByBandsWidth(true);
            

// setting calibration length
int calibrationLength = 6;
math.setCallibrationLength(calibrationLength);

// type of evaluation of instant mental levels
boolean independentMentalLevels = false;
math.setMentalEstimationMode(independentMentalLevels);

// number of windows after the artifact with the previous actual value
int nwinsSkipAfterArtifact = 10;
math.setSkipWinsAfterArtifact(nwinsSkipAfterArtifact);

// calculation of mental levels relative to calibration values
math.setZeroSpectWaves(true, 0, 1, 1, 1, 0);

// spectrum normalization by bandwidth
math.setSpectNormalizationByBandsWidth(true);
            

# setting calibration length
calibration_length = 6
math.set_calibration_length(calibration_length)

# type of evaluation of instant mental levels
independent_mental_levels = False
math.set_mental_estimation_mode(independent_mental_levels)

# number of windows after the artifact with the previous actual value
nwins_skip_after_artifact = 10
math.set_skip_wins_after_artifact(nwins_skip_after_artifact)

# calculation of mental levels relative to calibration values
math.set_zero_spect_waves(True, 0, 1, 1, 1, 0)

# spectrum normalization by bandwidth
math.set_spect_normalization_by_bands_width(True)
            

// setting calibration length
let calibrationLength: Int32 = 6
math.setCallibrationLength(calibrationLength)

// type of evaluation of instant mental levels
let independentMentalLevels = false
math.setMentalEstimationMode(independentMentalLevels)

// number of windows after the artifact with the previous actual value
let nwinsSkipAfterArtifact: Int32 = 10
math.setSkipWinsAfterArtifact(nwinsSkipAfterArtifact)

// calculation of mental levels relative to calibration values
math.setZeroSpectWavesWithActive(true, andDelta: 0, andTheta: 1, andAlpha: 1, andBeta: 1, andGamma: 0)

// spectrum normalization by bandwidth
math.setSpectNormalizationByCoeffs(true)
            

// setting calibration length
int calibration_length = 6;
[math setCallibrationLength:calibration_length];

// type of evaluation of instant mental levels
bool independent_mental_levels = false;
[math setMentalEstimationMode:independent_mental_levels];

// number of windows after the artifact with the previous actual value
int nwins_skip_after_artifact = 10;
[math setSpectNormalizationByCoeffs:nwins_skip_after_artifact];

// calculation of mental levels relative to calibration values
[math setZeroSpectWavesWithActive:true andDelta:0 andTheta:1 andAlpha:1 andBeta:1 andGamma:0];

// spectrum normalization by bandwidth
[math setSpectNormalizationByBandsWidth:true];
            

OpStatus opSt;
MathLibStartCalibration(tMathPtr, &opSt);
            

math.StartCalibration();
            

math.startCalibration();
            

math.start_calibration()
            

emotionalMath.startCalibration()
            

[math startCalibration];
            

void onBrainBitSignalDataReceived(Sensor *pSensor, BrainBitSignalData *pData, int32_t size, void *userData)
{
    RawChannels* bipolars = new RawChannels[size];
    for(int i = 0; i < size; i++){
        bipolars[i].left_bipolar = pData[i].T3 - pData[i].O1;
        bipolars[i].right_bipolar = pData[i].T4 - pData[i].O2;
    }

    MathLibPushData(tMathPtr, bipolars, size);	
    MathLibProcessDataArr(tMathPtr);
}
OpStatus outStatus;
BrainBitSignalDataListenerHandle lHandle = nullptr;
addSignalDataCallbackBrainBit(_sensor, onBrainBitSignalDataReceived, &lHandle, nullptr, &outStatus);
            

sensor.brainBitSignalDataReceived = data -> {
    RawChannels[] bipolars = new RawChannels[data.length];
    for (int i = 0; i < data.length; i++) {
        bipolars[i].leftBipolar = data[i].T3 - data[i].O1;
        bipolars[i].rightBipolar = data[i].T4 - data[i].O2;
    }
    math.pushData(bipolars);
    math.processDataArr();
};
            

sensor.brainBitSignalDataReceived = Sensor.BrainBitSignalDataReceived { data ->
    val bipolars = Array(data.size) {
        RawChannels(data[it].t3 - data[it].o1, data[it].t4 - data[it].o2)
    }
    math.pushData(bipolars)
    math.processDataArr()
}
            

private void onBrainBitSignalDataRecived(ISensor sensor, BrainBitSignalData[] data)
{
    RawChannels[] bipolars = new RawChannels[data.Length];
    for (var i = 0; i < data.Length; i++)
    {
        bipolars[i].LeftBipolar  = data[i].T3 - data[i].O1;
        bipolars[i].RightBipolar = data[i].T4 - data[i].O2;
    }
    math.pushData(bipolars);
    math.processDataArr();
}
...
sensor.EventBrainBitSignalDataRecived += onBrainBitSignalDataRecived;
            

def on_brain_bit_signal_data_received(sensor, data):
    raw_channels = []
    for sample in data:
        left_bipolar = sample.T3-sample.O1
        right_bipolar = sample.T4-sample.O2
        raw_channels.append(support_classes.RawChannels(left_bipolar, right_bipolar))
    
    math.push_data(raw_channels)
    math.process_data_arr()
...
sensor.signalDataReceived = on_brain_bit_signal_data_received
            

sensor?.setSignalDataCallbackBrainBit( { data in
    var bipolars : [EMRawChannels] = []
    for sample in data {
        let bipolarElement = EMRawChannels(leftBipolar: sample.t3.doubleValue - sample.o1.doubleValue, andRightBipolar: sample.t4.doubleValue - sample.o2.doubleValue)
        bipolars.append(bipolarElement!)
    }
    math.pushData(bipolars)
    math.processDataArr()
})
            

[sensor setSignalDataCallbackBrainBit:^(NSArray<NTBrainBitSignalData *> * _Nonnull data) {
    NSMutableArray<EMRawChannels*>* bipolars = [NSArray new];

    for(int i = 0; i < data.count; i++){
        double leftBipolar = [data[i].T3 doubleValue] - [data[i].O1 doubleValue];
        double rigntBipolar = [data[i].T4 doubleValue] - [data[i].O2 doubleValue];
        EMRawChannels* bipolarElement = [[EMRawChannels alloc] initWithLeftBipolar:leftBipolar andRightBipolar:rigntBipolar];
        [bipolar addObject: bipolarElement];
    }

    [math pushData:bipolars];
    [math processDataArr];       
}];
            

RawChannelsArray* samples = new RawChannelsArray[SAMPLES_COUNT];
...
MathLibPushDataArr(tMathPtr, samples, SAMPLES_COUNT);
MathLibProcessDataArr(tMathPtr);
            

var samples = new RawChannelsArray[SAMPLES_COUNT];
math.PushDataArr(samples);
            

var samples = new RawChannelsArray[SAMPLES_COUNT];
math.pushDataArr(samples);
math.processDataArr();
            

samples = []
math.push_data_arr(samples)
math.process_data_arr()
            

var samples: [[NSNumber]] = [[]]
math.pushDataArr(samples)
math.processDataArr()
            

NSArray<NSArray<NSNumber*>*>* samples = [NSArray new];
[math pushDataArr:samples];
[math processDataArr];
            

OpStatus os;
bool calibrationFinished = false;
MathLibCalibrationFinished(tMathPtr, &calibrationFinished, &os);
// and calibration progress
int calibrationProgress = 0;
MathLibGetCallibrationPercents(tMathPtr, &calibrationProgress, &os);
            

bool calibrationFinished = math.CalibrationFinished();
// and calibration progress
int calibrationProgress = math.GetCallibrationPercents();
            

boolean calibrationFinished = math.calibrationFinished();
// and calibration progress
int calibrationProgress = math.getCallibrationPercents();
            

calibration_finished = math.calibration_finished()
# and calibration progress
calibration_progress = math.get_calibration_percents()
            

let calibrationFinished = math.calibrationFinished()
// and calibration progress
let calibrationProgress = math.getCallibrationPercents();
            

bool calibrationFinished = [math calibrationFinished];
// and calibration progress
UInt32 calibrationProgress = [math getCallibrationPercents];
            

OpStatus opSt;

int size = 0;

// Reading mental levels in percent
MathLibReadMentalDataArrSize(tMathPtr, &size, &opSt);
MindData* mental_data = new MindData[size];
MathLibReadMentalDataArr(tMathPtr, mental_data, &size, &opSt);

// Reading relative spectral values in percent:
MathLibReadSpectralDataPercentsArrSize(tMathPtr, &size, &opSt);
SpectralDataPercents* sp_data = new SpectralDataPercents[size];
MathLibReadSpectralDataPercentsArr(tMathPtr, sp_data, &size, &opSt);
            

// Reading mental levels in percent
MindData[] mentalData = math.ReadMentalDataArr();

// Reading relative spectral values in percent
SpectralDataPercents[] spData = math.ReadSpectralDataPercentsArr();
            

// Reading mental levels in percent
MindData[] mentalData = math.readMentalDataArr();

// Reading relative spectral values in percent
SpectralDataPercents[] spData = math.readSpectralDataPercentsArr();
            

# Reading mental levels in percent
mental_data = math.read_mental_data_arr()
# Reading relative spectral values in percent
sp_data = math.read_spectral_data_percents_arr()
            

// Reading mental levels in percent
let mindData = math.readMentalDataArr()

// Reading relative spectral values in percent
let spData = math.mathLibReadSpectralDataPercentsArr()
            

// Reading mental levels in percent
NSArray<EMMindData*>* mindData = [math readMentalDataArr];

// Reading relative spectral values in percent
NSArray<EMSpectralDataPercents*>* spData = [math MathLibReadSpectralDataPercentsArr];
            

if(MathLibIsBothSidesArtifacted(tMathPtr)){
// signal corruption
}
            

if(math.IsBothSidesArtifacted()){
// signal corruption
}
            

if(math.isBothSidesArtifacted()){
// signal corruption
}
            

if math.is_both_sides_artifacted():
# signal corruption
            

if(math.isBothSidesArtifacted()){
    // signal corruption
}
            

if([math isBothSidesArtifacted]){
    // signal corruption
}
            

if(MathLibIsArtifactedSequence(tMathPtr)){
// signal corruption
}
            

if(math.IsArtifactedSequence()){
// signal corruption
}
            

if(math.isArtifactedSequence()){
// signal corruption
}
            

if math.is_artifacted_sequence():
# signal corruption
            

if(math.isArtifactedSequence()){
    // signal corruption
}
            

if([math isArtifactedSequence]){
   // signal corruption 
}
            

freeMathLib(tMathPtr);
            

math.Dispose();
            

math = null;
// native finalizer is run
            

del math
            

math = nil
            

math = nil;