Jens Gustedt

Robert C Seacord

Deferred cleanup and error handling in C

Keywords: C programming language, deferred execution, resource management, error handling, panic-recover Nettoyage langage de programmation C, exécution différée, gestion de ressources, traitement d'erreur, panique-recupération

This paper introduces the implementation of a C language mechanism for error handling and deferred cleanup adapted from similar features in the Go programming language. This mechanism improves the proximity, visibility, maintainability, robustness, and security of cleanup and error handling over existing language features. This feature is under consideration for inclusion in the C Standard. The library implementation of the features described by this paper is publicly available under an Open Source License at https://gustedt.gitlabpages.inria.fr/defer/.

Introduction and overview

The defer mechanism can restore a previously known property or invariant that is altered during the processing of a code block. The defer mechanism is useful for paired operations, where one operation is performed at the start of a code block and the paired operation is performed before exiting the block. Because blocks can be exited in multiple locations using a variety of mechanisms, operations are frequently paired incorrectly. The defer mechanism in C is intended to improve the proper pairing of these operations. This pattern is common in resource management, synchronization, and outputting balanced strings (e.g., parentheses or HTML tags). Additionally, a panic/recover mechanism allows error handling at a distance.

Most existing high-level languages such as C++, C#, Java, Go, D, and others include a general mechanism for resource management and error handling. C lacks such a mechanism, outside of its use of integer error codes and outmoded mechanisms such as errno. Consequently, resource management in C programs can be complex and error prone, particularly when a program acquires multiple resources. Each acquisition can fail, and resources must be released to prevent leaking. If the first resource acquisition fails, no cleanup is necessary, because no resources have been allocated. However, if the second resource cannot be acquired, the first resource needs to be released. Similarly, if the third resource cannot be acquired, the second and first resources need to be released, and so forth. This pattern results in duplicate cleanup code and be error-prone because of this duplication and the associated complexity.

C programmers need to manage the acquisition and release of resources. Because resources exist in limited quantities, it is always possible that a resource cannot be acquired because the supply of that resource has been exhausted. Examples of C standard library functions ISO (2018) that acquire resources include:

• storage: malloc, calloc, realloc, aligned_alloc • strings: strdup, strndup • streams: fopen, freopen • temporary file: tmpfile • threads: thrd_create • thread specific storage: tss_create • condition variable: cnd_init • condition variable: cnd_wait • mutexes: mtx_init, mtx_lock, mtx_timedlock, mtx_trylock Improper resource management and error handling frequently results in software vulnerabilities. Software security typically assumes an intelligent adversary that is working to compromise the security or possibly the availability of a system. A denial-of-service (DoS) attack occurs when legitimate users are unable to access information systems, devices, or other network resources resulting from the actions of an adversary [START_REF] Mirkovic | Internet Denial of Service: Attack and Defense Mechanisms[END_REF]. DoS attacks attempts frequently take the form of a resource-exhaustion attack that makes a computer resource unavailable or insufficiently available to the application. For example, if an attacker can identify an external action that causes memory to be allocated but not freed, memory can eventually be exhausted. Once memory is exhausted, additional allocations fail, and the application is unable to process valid user requests. Another variant of such erroneous resource management can be exploited in multi-threaded programs that use mutexes. By default, most systems have no provisions to cope with a mutex that is locked by a thread that exits. Other threads that try to access that same mutex will block, eventually causing a deadlock of the entire execution. Listing 1. An example with three deferred statements guard { void * const p = malloc (25) ; i f (! p ) break; defer free ( p ) ; void * const q = malloc (25) ; i f (! q ) break; defer free ( q ) ; i f ( mtx_lock (& mut ) == thrd_error ) break; defer mtx_unlock (& mut ) ; // all resources acquired } Another common error associated with manual memory management is the deallocation of memory more than once, without an intervening allocation. Double Free vulnerabilities can be exploited to execute arbitrary code with the permissions of a vulnerable process Seacord (2013). A common source of this error is the deallocation of memory while handling an error condition which is then deallocated again during normal cleanup procedures.

To cope with these shortcomings, the C standards committee (ISO/IEC JTC1/ SC22/WG14) is investigating the adaptation of Go's mechanism of deferred execution to [START_REF] Ballman | Defer Mechanism for C[END_REF]. This paper describes the feature including open design choices. The appealing properties of such an integration are

proximity -visibility -maintainability -robustness -security

There is evidence that this mechanism provides improved cleanup and error handling over existing C language features (such as goto or longjmp) and over features that could be imported from other languages such as C++, C# or Java like constructor/destructor pairings, exception handling, or finally blocks, or from compiler extensions such as explicit destructor functions (GCC compilers).

This paper describes a fully functional implementation of a defer mechanism for C that can be used without any compiler specific magic. In particular, it only uses already established features of C including nested for-loops, setjmp/longjmp, volatile qualifiers, and redefinition of standard features by macros. In addition, this implementation uses some common extensions, to reduce the use of setjmp/longjmp for unwinding across function boundaries and to avoid the use volatile qualifiers. Providing a complete implementation required fixing on a set of design options appropriate for a library only implementation. The final technical specification may eventually make other choices.

The following Section 2 introduces the feature set in more detail and explains these choices. In Section 3, we describe our implementation and its specific properties in more detail. We also describe possible uses of compiler specific properties for improvements and extensions. Section 4 provides a concise overview over the principal features as they are proposed.

Description

2.1. An example for static cleanup handling. Listing 1 shows a guarded block containing three deferred statements.

The defer keyword indicates that the evaluation of the following statement, such as a call to free, is deferred to the end of the guarded block. The deferred statement is evaluated regardless of how the guarded block exits. In Listing 1, the This approach has advantages over familiar C, C++, C# or Java solutions.

Inria

proximity: Cleanup code that releases resources (e.g., free or mtx_unlock) is collocated with the code that acquires these resources, making it easier for programmers to ensure statements are properly paired.

Other than C or C++ constructs, it also shares another advantage with C# or Java's finally blocks.

visibility: The cleanup code is clearly visible. This differs from atexit handlers or constructor/destructor pairs in C++, where cleanup code may be defined in a different translation unit.

For control flow that does not include return, exit, or other non-returning functions calls an equivalent control flow can be implemented with existing C language features. The guarded statement from Listing 1 is equivalent to the code segment in Listing 2. The if (false) statement guarantees that the deferred statements are not evaluated when they are first encountered. The labels and goto statements implement the backward branches to execute the deferred statements when the guarded block terminates.

A common C idiom for cleanup handling is to linearize resource management as shown in Listing 3.

This code has the advantage of making the conditional error handling code explicit (with three goto statements) but at the cost of proximity as the deallocation code is specified away from the allocations. This linearization requires a naming convention for the labels. For more complicated code the maintenance of these jumps can be error prone. Using defer instead eliminates the need for the programmer to define labels. maintainability: The cleanup code does not depend on arbitrary label names (C) or RAII classes (C++) and does not change when defer or break statements are added or removed.

All exits from a guarded block by break, return, thrd_exit, exit, or an interruption by a signal must be detected and acted upon. This is difficult to implement in C and requires try/catch blocks in C++. This feature promotes a fourth important property. This differs from C++'s handling of destructors, which are only guaranteed to be executed within a try/catch block.

For maintainability and robustness, we opted for objects to be accessed by reference within a deferred statement and not by value. Because defer is considered and has a similar syntax as other control structures, deferred statements or blocks should not be different from other blocks such as for if or for. Listing 1 illustrates why an access by reference is key to a successful usage. For example, the value of p could be changed by means of realloc. Then, if defer transfers the captured value to the deferred statement two errors would occur:

• The deferred call to free that uses the old (captured) value would be invalid.

• A new deferred statement with the new value of p would have to be added.

Inria

All of this is simpler if the object is evaluated only when the deferred statement is executed. Because the scope in which the deferred statement is executed is limited, compilers that implement defer natively can easily detect and diagnose a usage of a variable that is out of scope. Even for our macro/library based implementation compilers are able to reliably detect the misuse of local variables in deferred statements.

As stated earlier, vulnerabilities can occur if resources are not released, or released more than once. The improved usability of defer over existing mechanisms should help eliminated common errors that can result in vulnerabilities and improve security.

security: Resource leaks, deadlocks and double free vulnerabilities are reduced because of increased proximity and visibility of cleanup code to the resource acquisition code.

2.2. Design choices. The position paper [START_REF] Ballman | Defer Mechanism for C[END_REF] discusses several open design options. One aim of our paper is to evaluate these options in view of a fully functional implementation. This paper here assigns choices to three of of these design options and describes a functioning implementation by means of exiting C features.

Object access.

A deferred statement has to have access to a set of local variables that holds the state in which the cleanup is performed. The main design choices are here to access a variable by copy (copied when the defer is encountered) or by reference (when the deferred statement is evaluated). As previously discussed, we have opted for access by reference, but we also propose an specialized tool defer capture to copy values when the statement is encountered.

Dynamicity.

In practical examples the need to handle deferred statements dynamically (e.g., in if or for statements) arises. Unfortunately, dynamic handling of control flow requires that memory be allocated to maintain this state, and these allocations can also fail. We have opted for dynamic handling but we also provide a guarantee that a failure of resource allocation by the defer mechanism itself can be handled effectively by applications.

2.2.3. Scope. For the Go language, deferred statements are bound to the scope of a function body. For C, the need of declaring external functions could severely reduce the expressiveness of the feature, and so a guarded block indicated by a guard keyword has been introduced.

2.3. Dynamic vs. static control flow. Deferred statements are not evaluated when they are encountered, but only after the guarded block terminates. The order and number of times each deferred statement is executed can be made dependent from the context in which the defer occurs. For example, if the defer statement appears within a loop, a possible design choice is to execute the deferred statement as many times as the loop body is executed, only once, or to forbid the occurrence in such a context completely. Similarly, defer that are only executed conditionally because they are within an if , else or switch could be executed in the order they are met, in inverse lexicographic order (which might not be the same because of goto), or, again, not allowed in such contexts. Consequently, the first important design choice is to decide if the evaluation of deferred statements is determined statically at compile time or dynamically at run-time. Making this determination statically at compile time may result in more efficient execution, while making this determination at run-time is potentially less surprising to most programmers. Listing 4 shows a code fragment from within a guarded block. The deferred statement will be evaluated at the termination of the guarded block only in cases where the buffer referenced by p is dynamically allocated. To support such constructs, our implementation determines the order and number of times each deferred statement is executed at run-time. This approach requires allocating storage at run-time to maintain defer state, in this case at least a flag that holds the information to know if the deferred statement has to be executed at the end of the guard or not. If we allow as many executions of the deferred statements as are dynamically encountered, more state must be kept, but generally the state will fit into a small number of bytes, some integers, or pointers. Our implemented defer mechanism provides fault tolerance by continuing to operate properly in the event of the failure of a defer statement by ensuring the deferred statement is executed to release the resource.

For example, in Listing 4 defer_calloc and the defer statement may both exhaust memory. If the call succeeds (and a resource is allocated) but the defer mechanism fails (because the defer-internal state then exhausts memory), the call to free is evaluated immediately and the execution of the enclosing guarded block is terminated by a panic with an error code of DEFER_ENOMEM.

2.4. Panic/Recover. Error handling at distance is supported by the introduction of a panic/recover mechanism, which is similar to throw/catch in C++. Panic/recover depends on the defer mechanism to release resources during stack unwinding. Generally, a panic is a condition which requires unwinding one or several levels of deferred statements. Such a panic may occur implicitly if the run-time library detects or signals a fault, or explicitly by the use of a macro dedicated to that purpose.

The panic macro is called to indicate an abnormal execution condition. It triggers the execution of all active deferred statements of the current thread in the reverse order they are encountered, until either a deferred call to recover is executed or all deferred statements have been executed. If no recover statement is encountered, the function stack unwinds the caller's stack and executes all deferred statements registered in that stack frame. This process continues until a recover expression is encountered or all deferred statements have executed.

Our reference implementation applies the convention that user error codes passed to panic are always positive, and system error codes are generally negated errno numbers. To deal with such error codes in a portable way, equivalent POSIX error codes are provided with with a DEFER_ prefix.

System signal numbers cannot be use directly because they may conflict with errno numbers. Instead, all POSIX signal numbers have a constant that replaces Inria the SIG prefix by a DEFER_ prefix. For example, the DEFER_HUP constant represents the signal SIGHUP.

Two convenience macros simplify the use of this feature. The defer if macro is a pseudo selection statement and the recover_signal macro only acts on signals.

Once a deferred statement begins evaluation, the condition that led there can be investigated by means of recover. The recover function returns an integer value indicating why the deferred statement is executing. A return value of 0 indicates that the deferred statement is the result of a break, return, exit or similar. Any other value indicates that the deferred statement is executing as the result of a panic.

Handling the recovered error is the responsibility of the programmer. The programmer may re-issue the panic from within the deferred statement if it is impossible to recover at a particular level of abstraction.

2.5. Guarded blocks. In the proposal to the C standards committee [START_REF] Ballman | Defer Mechanism for C[END_REF] each function body implements a guarded block, such that an explicit guard statement is not necessary for many common use cases. Generally, this cannot be performed by macros but requires compiler magic. Consequently, eliminating the guard statement for the entire function body cannot be provided by a library-only implementation; a library-only implementation will always need a guard statement or similar feature that marks the context for a defer. Using the implementation specific function __builtin_frame_address our implementation can provide this feature for the GCC family of compilers by keeping track of the stack pointer, and other compilers that provide access to the stack pointer could do similarly.

Beyond the possibility of a library-only implementation, a guard keyword allows nesting guarded blocks without having to move inner blocks into their own functions. Go does not require nested constructs for this purpose, because lambdas provide a simple way to define an anonymous functions that can be used for encapsulation. In this paper, we use the phrase guarded block, regardless if a guard statement is given explicitly or if the function body provides the guarded block.

2.6. Augmented C library functions. Existing resource acquisition functions, including those defined by the C Standard library, such as malloc, can be augmented to panic if they encounter an out-of-memory condition. That has several benefits:

• Explicit error handling is not repeated at each call site.

• Programmer-installed deferred cleanup statements will be called, for example, to close files or to free memory allocations. • User code can recover from failures (panics) using recover; improving system robustness. Inspection of the generated assembly instructions for these functions shows little overhead for the fast execution path. This technique might also provide an alternative to run-time constraints found in the bounds-checked interfaces in Annex K of the C Standard ISO (2018), in a way that preserves the existing function prototypes. 2.7. Interoperability with C++. C++ provides destructors and catch clauses for releasing resources. The defer statement combines those two features into one.

This implementation provides features to translate between these mechanisms such that stack unwinding can be reliably performed in programs that mix C and C++. In particular, if called from C++ code, the C feature translates panics and requests for exit at the boundary into C++ exceptions. For this to work, C++ applications must establish a mark that indicates the current language is C++. When the C++ code includes <stddefer_codes.h> this is performed for any translation unit that contains the function main. • break ends a guarded block and executes all its defer clauses • return unwinds all guarded blocks of the current function and returns to the caller • thrd_exit unwinds all active deferred statements of the current thread and exits that thread • exit unwinds all active deferred statements of the current thread and exits the execution 1 • panic starts global unwinding of all guarded blocks • recover stops a panic and provides an error code The functionality of these interfaces is further detailed in Section 4. The existing features break, return, thrd_exit and exit gain new functionality; four principal new features are added to the set, namely guard, defer, panic and recover.

The former are overloaded by macro definitions that take effect as soon as the library header is included. 2 Additionally, when linked to legacy object files, C library functions should be used consistently. If the platform supports it, this can be achieved by providing --wrap=exit or similar arguments to the linker.

3.1. Preprocessing language extensions. The reference implementation is unconventional because it uses preprocessor macros that result in deeply nested for loops to implement the principal macros defer and guard. It does so to ensure a mostly library implementation through macros, that should work with any C compiler. This technique leads to code that is difficult to read and consequently this technique is not recommended for programmer-written code. This technique hides relatively complicated code behind a single keyword (such as guard or defer) that can also be used as a prefix to another statement. Use of the preprocessor allows for the declaration of local state variables, to perform actions before or after the dependent statement, and to conditionally select an execution or to skip it when necessary.

An intermediate processor is used for the production of the C (and C++) code for the library itself called shnell. The intermediate processor uses #pragma annotations for the definition of complicated macros and for code unrolling. The distribution also contains the expanded sources and users don't need to perform this processing to use the feature.

1 For C threads, the behavior when terminating an execution that still has several active threads is undefined.

2 The changes to the library functions may be suppressed by providing the environment variable DEFER_NO_WRAP to the build.

RR n°9385

The techniques used in this implementation (but for the omission of the top level guard as previously mentioned) show that the semantics that this libraryonly implementation provides are not extending the usual semantics of C, and that their translation and optimization are not more challenging than existing C code.

3.2.

Using longjmp for control flow. C library features setjmp/longjmp are used as a principal feature to jump to deferred statements within the same function or to unwind the call stack. We distinguish jumps that are known to target the same function and those that are known to jump to another function on the call stack, named _Defer_shrtjmp and _Defer_longjmp, respectively. The unwind for a return will usually consist entirely of short jumps, whereas unwinding of the call stack by exit and other means always initiates a long jump.

The guarantees for the state of local variables that setjmp/longjmp provides are weaker than those needed in our context. Consequently, atomic variables and fences are used to guarantee up-to-date values. If these are not available, this implementation will work with the precautions described for defer.

Computed goto.

The implementation can distinguish cases where all jumps are finally implemented as long, or platforms where some shortcut for a short jump can be taken. Currently this is only implemented for GCC and related compilers that implement a computed goto. A computed goto allows a programmer to take the address of a label and then go to that address. Such a specialized implementation performs better during unwinding (primarily comprised of simple jumps), but still must track all the guarded blocks and defer clauses with setjmp because these could be jumped to from other functions or from signal handlers.

3.4. Captured Values. Following existing C semantics for control statements implies that object values are accessed when the deferred statements are evaluated and not when the defer itself is encountered. This policy appears to be consistent with the expectation of a majority of programmers that we could reach in a poll where out of 387 developers there was a 2:1 preference for the value being read at the time the deferred statements are evaluated (66.9%) rather than when the defer statement is encountered (33.1%).

This policy helps to react to changes to the variable during processing. For example, a pointer value that is to be freed could be rewritten by calls to realloc to resize the object. Consequently, our implementation follows this policy. The only restriction is that local variables that are used within a deferred statement must be alive when the deferred statement is executed at the end of the guarded block.

If C is extended with lambdas a defer statement could be redesigned to accept an equivalent syntax

defer [&]( void ) { // deferred statements }
Namely, the defer statement could receive a lambda with no parameters and executes it when leaving the guard. All objects in this case are captured by reference. Such an extended defer statement could also capture local objects by copy. In lambda notation this would appear as follows:

defer [& , ptr ]() {
// deferred statements }

Inria

In this case, a copy of ptr is created when the defer statement is encountered, and the value of this copy is used when the deferred statement is evaluated, even if the original value has been modified. In our implementation, copy semantics can be achieved by using the defer capture macro: defer statement Deferred statements may not themselves contain guarded blocks or other defer clauses, and must not call functions that may result in a termination of the the execution other than panic. Additionally, such a call to panic must only occur after the current panic state had been tested with recover.

The deferred statement may use any local object that is visible where the defer is placed and that is still alive when the deferred statement is executed, that is at the end of the surrounding guard or function body. This property is verifiable at compile time, and a violation usually results in an abortion of the compilation. This implementation here puts everything in place, such that a deferred statement uses the last-written value for all objects, but the success of that depends on the presence of some synchronization features.

If such synchronization features are not available, local objects that may change between the defer itself and the execution of the deferred statement and that are used in the deferred statement must be declared volatile to ensure the latest written value is read. In general, objects used inside a deferred statement should be const qualified to use the original value, and volatile qualified to use the last written value.

To keep track of the dynamic state of the deferred statements our implementation uses storage allocation functions calloc and free to maintain a list of defer clauses. In case that calloc fails, the defer clause is executed and the entire execution is unwound by means of panic and an error argument of -DEFER_ENOMEM. With this strategy, it can be guaranteed that all cleanup code for resources that are allocated before the calloc failure is evaluated, and that any call to recover in a deferred statement finds the execution in a well-defined state. 4.1.1. defer capture Macro. The defer capture macro captures object values and defers execution of the deferred statement.

defer capture ([ id0 [ , id1 [ , id2 ..

.]]]) statement

The argument list must be empty, or contain a list of objects. These objects are evaluated and their values stored. When the deferred statement is finally executed, address-less local objects with the same name and type (but const-qualified) are placed before the deferred statement, and are initialized with these frozen values. 4.2. guard Statement. The guard statement marks a block as guarded by the defer mechanism.

guard compound-statement
If a guarded block is terminated normally or with a break or continue statement, all deferred statements that have been registered by a defer statement are executed in the reverse order in which they were encountered.

There is also a macro defer break that can be used in contexts where break or continue statements would refer to an inner loop or switch statement. Also, return, exit, quick_exit and thrd_exit all trigger the execution of deferred statements, up to their respective levels of nesting of guarded blocks.

Other standard means of non-linear control flow out of or into the block (goto, longjmp, _Exit, abort), do not invoke that mechanism and may result in memory leaks or other damage when used within such a guarded block. Our implementation provides replacement for some of these language features such as defer goto and defer_abort.

4.3. panic Macros. The panic macros unwind the entire call stack and execute all deferred statements in the thread.

noreturn void panic ( int C ) ; noreturn void panic ( int C , void F ( int ) ) ;

After all deferred statement of the current thread are executed in reverse order in which the defer statements have been encountered, in the last stack frame that has a defer or guard statement, F(C) is executed. Here F is a defer_handler and C is an error code.

If provided, defer_handler is meant to be a function that terminates the execution, either of the current thread or of the whole program. If omitted, F defaults to an implementation specific handler. Valid defer handlers are all functions that have the correct signature and that terminate the current thread or the whole execution. Prominent candidates from the C library are exit and thrd_exit; the first allows to stop the whole execution; the latter, the current thread. Using other handlers such as quick_exit or _Exit) provides the possibility to manage the set of exit handlers evaluated before the program stops.

This unwind chain can be stopped with a recover call within one of the evaluated deferred statements (or if a defer if clause is used).

The error code C should be negative if it is supposed to map to a system defined error condition (as if for errno or a caught signal). Otherwise, all user supplied error numbers should be positive. When unwinding an error condition triggered by the system, the error code will always be negative. The macro defer_assert is similar to the assert macro in that it asserts that a specific condition holds. It cannot be switched off at compile time but the panic that is triggered can be recovered. In particular, the compiler can detect that the following code can only be reached if the condition holds, and optimize the code accordingly. For example, the following asserts that pointer p is non-null, and otherwise triggers a ENOMEM panic.

defer_assert ( p , -DEFER_ENOMEM , " allocation failed " ) ; // p is now assumed to be non -null Inria 4.4. Regular termination. There are three severity levels for termination of a guarded block, break or similar just terminates the guarded block, return terminates all guarded blocks of the same function and exit or panic of the same thread across all function calls.

The implementation augments break (within a guard) and return by this functionality. This is achieved by overloading theses features by macros, a technique that that the C standard explicitly allows.

For the C library functions that terminate a thread or the whole execution, the functionality of the following functions is the same as their unprefixed C library counterparts.

noreturn void defer_exit ( int ) ; noreturn void defer_thrd_exit ( int ) ; noreturn void defer_quick_exit ( int ) ; noreturn void defer__Exit ( int ) ;

Instead of terminating the thread or the execution immediately they will unwind the stack of collected deferred statements.

Code that is compiled with the <stddefer.h> header will also just replace calls to the C library functions noreturn void exit ( int ) ; noreturn void thrd_exit ( int ) ; noreturn void quick_exit ( int ) ; by calls to their corresponding wrappers. 3Other code that is not compiled with it, may still call the C library functions directly without unwinding. Mixed units of different origin should use linker tricks such as -wrap-function=exit to replace these calls by the wrapped ones. 4.5. recover Function. The recover function stops a panic and returns an error code.

int recover ( void ) ;

A call to this function must reside within a deferred statement. This will only stop unwinding of the panic if the error code had not been 0. Normal break, return, thrd_exit, exit etc will not be be stopped and the guarded block, function, thread or program will finish when all the associated deferred statements have been executed.

If the error code is non-zero, execution of the defer clause then continues as if the nearest guarded block had been broken by break. That is, the execution of the defer clauses of that particular guarded block are continued and then execution resumes at the end of that guarded block.

In general, error codes provided by the system will be negative and user provided error codes shall be positive. To determine if a system error occurred you may, for example, compare the value to -ERANGE, or, if the error originated from a caught signal to DEFER_SIGNO(SIGTERM). This stops an unwind originating from a panic call or from a signal with non-zero error code (or similar), returns the error code in a local int variable named err, and executes the depending statement if the value is non-zero, or an alternative else clause, if any, if the value is zero. The else clause is optional.

The variable err can then be used inside the if or else clauses, but it is not mutable and its address cannot be taken. And it is a bit useless within the else clause, because we know that it is zero, there. 4.5.2. defer_show Macro. The defer_show macro shows information about the latest panic on stderr. This can be used as diagnosis tool after a recover to provide feedback to the user what went wrong with the execution. 4.6. Signals. The execution of a deferred statement can be triggered in two ways. First, it can be explicit by leaving a guarded block when coming to the end of it or by using break, exit . . . from within as discussed above.

Then it can be triggered implicitly from a signal handler. Two signal handlers are provided defer_sig_flag and defer_sig_jump, and a function recover_signal may help to process signals. The provided signal handlers use extensions that might not be available everywhere. In particular, they use the fact that threadlocal variables can be accessed from a signal handler. The implementation does not install any of these handlers by default.

int recover_signal ( void ) ;

The function differs from recover because it only reacts on signals that are caught by the provided signal handlers (defer_sig_flag and defer_sig_jump), not on other break or panic events. Also, the function returns the number of the signal that has been caught, not the raw error code as it is maintained by the library. 4It can be used in any context and does not need a surrounding guarded block or defer clause. Its cost is the lookup of a thread local variable and a memory synchronization with that variable. So it should probably not be placed inside performance critical loops.

When a signal occurs within a guarded block or defer clause and is not recovered by means of recover or recover_signal, the execution is considered to be compromised, a panic results, and the deferred statements of the thread are unwound.

A typical use of this in conjunction with defer_sig_flag would be an active loop, see Listing 7. Here, an INT event can occur at any point of the computation before or inside the while loop. At the first detection of a signal, the while loop Listing 7. A loop that is interruptible by a signal int main ( void ) { // Establish the handler for user interrupts . signal ( SIGINT , defer_sig_flag ) ; while ( active ) { i f ( recover_signal () ) { puts ( " caught signal , stopping loop " ) ; break; } ... do whatever you have to do ... } } then is broken, and execution continues after it. This guarantees that the whole loop body is always executed until its end.

The function void defer_sig_flag ( int sig ) ;

provides a signal handler that flags the execution of a thread and is not too intrusive. It immediately hands control back to the user code and the effective handling of the event is delayed until the application code reaches the end of a guarded block and/or actively issues a recover_signal operation to receive the code. Generally this might be used to handle signals triggered by the user via the terminal. In contrast to that, this function is not suited for signals that jump back to exactly the same code location where some repair work has to be performed to continue, such as invalid arithmetic or segmentation faults. In such situations we need void defer_sig_jump ( int sig ) ; a signal handler that flags the execution of a thread and jumps to the first deferred statement, an action that is much more intrusive and that assumes that the signal is caught by the same thread that is to perform that defer clause. Not all platforms may guarantee this.

The C standard function signal itself is not well suited for this kind of handler, because signals should be switched off during the handling of such interrupts. A given platform (such as POSIX) might propose tools are more appropriate than signal to handle such faults. These functions behave like their unprefixed C library counterparts, only that instead of returning a null pointer they panic on failure. For example, defer_malloc, panics with -DEFER_EINVAL when called with a size of 0 and with -DEFER_ENOMEM when the allocation fails.

This approach eliminates the user requirement to check of the result of such a function and subsequent code is guaranteed that the return value is a non-null Listing 8. An example for a simple buffer reallocation void * p = malloc ( small ) ; defer free ( p ) ; // use p defer { // save some precious values from p } p = defer_realloc (p , huge ) ; pointer. For example other than for realloc, Listing 8 shows a valid idiom. The assignment to p is only executed if the call to defer_realloc is successful, and the call to free in the deferred statement will always use the good (= last allocated) value for p. Also, if it fails execution is immediately transferred to the currently deferred statements, and the necessary terminal actions are taken as indicated, first the second deferred statement may save values from p and then p is freed.

A compilation that sets the DEFER_MALLOC_WRAP macro replaces all usage of the C library storage allocation functions by the wrapped versions. By using this feature whole projects can switch to such an error checking policy for storage allocation at once.

Conclusion

An effort is underway to add a mechanism for error handling and deferred cleanup to the C standard by providing a new library clause for a new header with the proposed name <stddefer.h> [START_REF] Ballman | Defer Mechanism for C[END_REF]. In this paper we have presented a fully functional library implementation of these features, that in its most restricted form only uses established C constructs. We have shown that the defer concept itself does not extend the semantics of C, but provides language constructs to allow programmers to develop maintainable, robust, and secure code.

The library described by this paper is publicly available under a BSD 3-Clause Open Source License. The project page is located at https://gustedt.gitlabpages.inria.fr/defer/.

Acknowledgments. Thanks to Aaron Ballman, Alex Gilding, JeanHeyd Meneide, Miguel Ojeda, Tom Scogland, Martin Uecker, Freek Wiedijk, and Simon Harraghy for their contributions to this work.

Inria

Figure 1 .

 1 Figure 1. Control flow of a guarded block with three defers

Listing 4 .

 4 Conditional defer // create a local buffer as a compound literal double * p = ( len > MLEN ) ? 0 : ( double [ MLEN ]) {0}; // if len is too big , allocate from the heap i f ( p ) { p = defer_calloc ( len , sizeof double ) ; defer free ( p ) ; } // p is a valid pointer until the scope is left

  Principal features 4.1. defer Statement. The defer statement ensures the execution of the deferred statement at the end of the guarded block.

  4.3.1. defer_assert Macro. The defer_assert macro asserts a run-time condition or panics.

  void defer_assert ( condition , code , string ) ;

  4.5.1. defer if Macro. The following defer if macro invocation: d e f e r i f ( err ) statement-1 e l s e statement-2is equivalent to the following defer clause:

4. 7 .

 7 Storage management functions. void * defer_malloc ( size_t size ) ; void * defer_calloc ( size_t nmemb , size_t size ) ; void * defer_realloc ( void * ptr , size_t size ) ; void * defer_aligned_alloc ( size_t alignment , size_t size ) ;

Table 1 .

 1 C error codes and C++ exceptions

	error code (C or POSIX) exception (C++)
	0	std::defer_exception(0)
	-DEFER_EBADF	std::ios_base::failure
	-DEFER_EDOM	std::domain_error
	-DEFER_EINVAL	std::invalid_argument
	-DEFER_ENOMEM	std::bad_alloc
	-DEFER_EOVERFLOW	std::overflow_error
	-DEFER_ERANGE	std::out_of_range
	-DEFER_EUNDERFLOW	std::underflow_error
	other	std::defer_exception(other)

RR n°9385

A compilation that set the macro DEFER_NO_WRAP, will not replace the usage of the C library termination functions by the wrapped versions as presented above. The use of this macro is not recommended. RR n°9385

An auxiliary macro DEFER_SIGNO can be used to translate between signal numbers and raw error codes.Inria

rue du Jardin Botanique CS20101 54603 Villers-lès-Nancy Cedex Publisher Inria Domaine de Voluceau -Rocquencourt BP 105 -78153 Le Chesnay Cedex inria.fr ISSN 0249-6399

Nevertheless, to ensure that resources are released by such a C++ program it is a good idea to catch all exceptions. This ensures that all destructors down to and including in main are called when the stack is unwound. An easy way to achieve this is to establish main as a try-catch block as shown in Listing 5. This also works for functions that are called with their own threads.

Interoperability for C++ code that might be called from C requires that a wrapper testing_CPP for a function testing is established, as shown in Listing 6.

To properly interoperate when invoked by a C program, the C++ program must:

• declare a local variable of type std::defer_boundary for which the constructor records the state prior to the call, • implement a try/catch clause that guarantees that exceptions are caught and that all the destructors are called • a call to the method panic that either propagates any caught exception (if the caller is also C++) or that translates an exception to a panic (if the caller is C). Automatic generation of wrappers has not yet been implemented. Bidirectional translation between C defer and C++ exceptions is supported through these mechanisms. To improve the usability of this mechanism, the defer error codes are translated into standard C++ exceptions as shown in Table 1. In contrast to other values, an error code of 0 does not correspond to a panic but to a regular termination as by thrd_exit or exit.

Implementation Details

The important interfaces of this tool are:

• guard prefixes a guarded block • defer prefixes a defer clause Inria


Olga O Krasnovskaya

Vladislav M Malinnikov

Natalia S Dashkova

Vasily M Gerasimov

Irina V Grishina

∥,○,⬡ Igor I Kireev

Svetlana V Lavrushkina

Pavel A Panchenko

Marina A Zakharko

Pavel A Ignatov

Olga A Fedorova

Gediminas Jonusauskas

Dmitry A Skvortsov

Sergey S Kovalev

Elena K Beloglazkina

Nikolay V Zyk

Alexander G Majouga #

Alexander G Majouga

Thiourea Modified Doxorubicin: A Perspective pH-Sensitive Prodrug

la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

■ INTRODUCTION

Doxorubicin -an antitumor antibiotic -is an effective and commonly used chemotherapeutic agent and is able to embed into the double helical structure of cell DNA, inhibiting RNA and DNA synthesis and thereby leading to apoptosis of cancer cells. [START_REF] Shu | Quercetin reverses the doxorubicin resistance of prostate cancer cells by downregulating the expression of c-met[END_REF] Doxorubicin and its modified form doxil are widely used in cancer therapy. [START_REF] Du | Synthesis and Evaluation of Doxorubicin-Loaded Gold Nanoparticles for Tumor-Targeted Drug Delivery[END_REF] Despite the effectiveness of doxorubicin, there is a high chemotherapeutic failure rate due to its low specificity toward tumor tissues, dose-dependent resistance to therapy, and strong cardiotoxicity. [START_REF] Luu | Role of Endothelium in Doxorubicin-Induced Cardiomyopathy[END_REF] Development of doxorubicin prodrugs, modified with a target-recognizing fragment, [START_REF] Ding | A Novel Doxorubicin Prodrug with GRP78 Recognition and Nucleus-Targeting Ability for Safe and Effective Cancer Therapy[END_REF] as well as pH-sensitive prodrugs capable of releasing a cytotoxic agent in weakly acidic tumor tissues, [START_REF] Gonzaĺez-Meńdez | Optimized synthesis, characterization and in vitro systematic evaluation of adamantane-doxorubicin prodrugs sensitive to pH in breast cancer cells[END_REF] is a relevant task for medical chemistry.

Acidic extracellular pH e is a major feature of tumor tissue; extracellular acidification is considered to occur in the presence of lactic acid, which accumulates due to anaerobic glycolysis in hypoxic cancer cells. [START_REF] Kato | Acidic extracellular microenvironment and cancer[END_REF][START_REF] Griffiths | Are cancer cells acidic?[END_REF] Also, the possible reason of acidification is an CO 2 accumulation, due to the pentose phosphate pathway, which is highly active within tumor cells, and the following oxidization by the enzyme carbonic anhydrase (CA), which leads to the increase of carbonic acid concentration. [START_REF] Han | Fluorescent Indicators for Intracellular pH[END_REF][START_REF] Helmlinger | Acid production in glycolysis-impaired tumors provides new insights into tumor metabolism[END_REF] Acidic pH e not only leads to activation of some lysosomal enzymes but also increases resistance to certain types of chemotherapy, [START_REF] Poomthavorn | Activation of a prometastatic gene expression program in hypoxic neuroblastoma cells[END_REF] through the unforeseen metabolism of therapeutic molecules resulting in high outflow of drugs from tumor cells. In particular, acidic pH e reduces cytotoxicity of antitumor drugs with weak base pK a : doxorubicin, mitoxantrone, and daunorubicin. [START_REF] Vukovic | Influence of low pH on cytotoxicity of paclitaxel, mitoxantrone and topotecan[END_REF] In the early stages of breast cancer, the high CAIX enzyme level is a predictive marker of doxorubicin resistance. [START_REF] Betof | Carbonic anhydrase IX is a predictive marker of doxorubicin resistance in early-stage breast cancer independent of HER2 and TOP2A amplification[END_REF] Acidic pH e also plays a role in the drug resistance of tumor cells due to the increased p-glycoprotein expression, that increases drug efflux. [START_REF] Lotz | Role of the tumor microenvironment in the activity and expression of the p-glycoprotein in human colon carcinoma cells[END_REF][START_REF] Thews | PET imaging of the impact of extracellular pH and MAP kinases on the p-glycoprotein (Pgp) activity[END_REF] There are several strategies that can be used to develop pHsensitive prodrugs capable of cytotoxic drug release in the acidic environment of tumor cells, and they are described in many of the newest scientific publications: pH-dependent release of Dox from its micellous conjugate with vitamin E, via pH-sensitive hydrazone bond; [START_REF] Xiong | A pH-sensitive prodrug strategy to co-deliver DOX and TOS in TPGS nanomicelles for tumor therapy[END_REF] adamantane-modified Dox via pH-sensitive hydrazone linker, capable of releasing free Dox at pH 4.5; [START_REF] Gonzaĺez-Meńdez | Optimized synthesis, characterization and in vitro systematic evaluation of adamantane doxorubicin prodrugs sensitive to pH in breast cancer cells[END_REF] Doxconjugated smart polymeric self-assambled micelles, prepared via an imine linkage, which exhibited the pH-triggered chargeconversion property and accelerated drug release at tumor pH; [START_REF] Ma | pHsensitive doxorubicin-conjugated prodrug micelles with chargeconversion for cancer therapy[END_REF] polymeric micelles delivery system based on block copolymers of poly(L-lactic acid)-β-poly(ethylene glycol) β-poly(L-histidine)-TAT (transactivator of transcription) and poly(Lhistidine)-β-poly(ethylene glycol). Such micelles have been proven to increase the cytotoxicity of doxorubicin in several multidrug-resistant tumor cell lines through the lifetime increase of the active molecule. [START_REF] Lee | Super pH-sensitive multifunctional polymeric micelle for tumor pHe specific TAT exposure and multidrug resistance[END_REF] Also, conjugation of docosahexaenoic acid (DHA) to doxorubicin (Dox) with a pH-sensitive hydrazone linker at the 13 position formed a lipophilic prodrug and demonstrated higher anticancer activity in vivo than free doxorubicin; the authors suggested a pH-sensitive Dox release and higher cellular accumulation than free Dox but have not confirmed it experimentally. [START_REF] Wang | Synthesis and preliminary antitumor activity evaluation of a DHA and doxorubicin conjugate[END_REF] We have proposed another approach to the synthesis of pHsensitive prodrugs, Dox-thiourea drug modification, that would be able to simultaneously release two different therapeutic agents in the acidic pH (pH ≥ 6.5/7.5). [START_REF] Swietach | The chemistry, physiology and pathology of pH in cancer[END_REF] Thioureas are perspective prodrugs because in the acidic environment of tumor tissues they are cyclized to corresponding thiohydantoins, releasing free doxorubicin. At the same time the resulting thiohydantoin, depending on the structure of the initial thiourea, may have different pharmacological properties. 2-Thiohydantoins exhibit a wide variety of biological properties: antitumor, [START_REF] Majumdar | Design, synthesis and evaluation of thiohydantoin derivatives as potent topoisomerase I (Top1) inhibitors with anticancer activity[END_REF] antiviral, [START_REF] Chang | Traceless and Stere-oselective Synthesis of Tetrahydro-β-carbolinethiohydanby Microwave Irradiation[END_REF] anti-inflammatory, [START_REF] Roue | Synthesis of the marine alkaloid leucettamine B[END_REF] anticonvulsant. [START_REF] Fuentes | Stereocontrolled synthesis of thiohydantoin spironucleosides from sugar spiroacetals[END_REF][START_REF] Beloglazkina | A novel catalyst for alkene epoxidation: a polymersupported CoIILCl2 {L = 2-(alkylthio)-3-phenyl-5-(pyridine-2-ylmethylene)-3,5-dihydro-4H-imidazole-4-one} complex[END_REF] One of the most convenient methods of 2-thiohydantoins synthesis is the acid-catalyzed cyclization of the corresponding thioureas. [START_REF] Kuznetsova | An Improved Protocol for Synthesis of 3-Substituted 5-Arylidene-2-thiohydantoins: Two-step Procedure Alternative to Classical[END_REF] In this study, we have chosen thiohydantoin albutoin as a simple structure model drug -an anticonvulsant [START_REF] Tripathi | Design & synthesis of N′-[substituted] pyridine-4-carbohydrazides as potential anticonvulsant agents[END_REF][START_REF] Finnerup | Pharmacotherapy for neuropathic pain in adults: a systematic review and meta-analysis[END_REF] -that was evaluated by the United States Food and Drug Administration but not approved. [START_REF] Shorvon | Drug treatment of epilepsy in the century of the ILAE: The second 50 years, 1959-2009[END_REF] Albutoin, in contrast to the structural similar anticonvulsant diphenylhydantoin, did not not have toxicityinduced side effects. [START_REF] Green | Clinical evaluation of albutoin[END_REF] Doxorubicin is highly hydrophilic and has a short half-life, and its use is associated with severe side effects at high doses. [START_REF] Bridewell | Differential actions of aclarubicin and doxorubicin: the role of topoisomerase I[END_REF] Doxorubicin implements its cytotoxicity by inhibiting topoisomerase II enzyme. [START_REF] Capranico | Influence of structural modifications at the 3′ and 4′ positions of doxorubicin on the drug ability to trap topoisomerase II and to overcome multidrug resistance[END_REF] The amino group in the 3′-position is not essential for topoisomerase II-targeting activities, because it can be replaced by a hydroxyl group without reduction of activity (doxorubicin analog annamycin). However, conjugation of the 3′-amino group through an amide bond reduced the anticancer activity against the leukemia, breast, ovarian, and colon cancer cell lines, suggesting that the presence of a free amino group is required for anticancer activity of doxorubicin. [START_REF] Gallois | Comparison of the interaction of doxorubicin, daunorubicin, idarubicin and idarubicinol with large unilamellar vesicles: Circular dichroism study[END_REF] Thus, we have suggested that the modification of the amino group of doxorubicin with thiourea will reduce the general toxicity of the corresponding prodrug.

To prove the ability of sterically hindered thioureas to cyclize in a weakly acidic medium, we have synthesized a model of pHsensitive thiourea: a FRET pair based on naphthalenimide and fluorescein. The present paper reports our initial studies on the synthesis of the novel thiourea derivative of doxorubicin -the acid-hydrolyzable twin prodrug by the modification of the N-3′ position of Dox through amide bond formation and its anticancer activity. The cytotoxic effects and cellular accumulation of the synthesized compound were evaluated against androgen receptor negative PC3 prostate cancer cell lines.

■ RESULTS AND DISCUSSION

The Studies of pH-Sensitive Thioureas-Based Prodrugs Using a FRET-Pair Model. To assess the cyclization of thiourea derivatives in a weakly acidic medium, we have proposed to synthesize a sterically hindered fluorescent derivative of 2-thiohydantoin acid containing the donor naphthalimide and acceptor fluorescein fragments (Scheme 1). In the case of this FRET pair, the Forster resonance energy transfer must be disrupted by acid-catalyzed cyclization, leading to fragmentation of the initial molecule to naphthalenimide and fluorescein components, which will lead to a significant change in the fluorescence spectrum and can be easily monitored by spectral methods (Figure 1).

Thus, the study of FRET-pair fluorescence, where resonant energy transfer is observed, can show whether fluorophores are part of the same molecule or not. In case the acid catalyzed cyclization occurs, the resonance transfer of energy will cease, clearly demonstrating the acid-catalyzed cyclization of thiourea with the release of the amide fragment and the formation of the 2-thiohydantoin.

The spatial structure of the FRET model optimized by molecular mechanics in the gas phase is shown in Figure 2. The calculated distance between the elements of the FRET pair is about 12.8 Å, and there is also a significant overlap of the emission spectrum of the donor fragment and the absorption spectrum of acceptor moiety (see section 2.1.2.1), which indicates the possibility of resonant transport in this system.

Synthesis of the pH-Sensitive Thiourea as a FRET-Model Molecule. The synthesis of the FRET pair model (thiourea 10) was carried out according to Scheme 1.

The FRET pair was synthesized through the ten-stage synthesis, the key stages in which were copper-catalyzed azide-alkyne cycloaddition reaction of propargyl ester 2 with azide 8 in mild conditions and the reduction of the resulting triazole 9 with the formation of thiourea 10. Target compounds were isolated by high-performance liquid chromatography.

The detailed description of the experimental procedures is given in the Supporting Information.

Study of FRET-Model pH-Sensitivity. Theoretical Study of Resonant Energy Transfer in a FRET Model. Effective resonant energy transfer between fluorophores is possible if the distance between them is less than 10 nm, and the emission spectrum of the donor is overlapping with the acceptor absorption spectrum. [START_REF] Nikiforov | Development of homogeneous binding assays based on fluorescence resonance energy transfer between quantum dots and Alexa Fluor fluorophores[END_REF] The superposition of experimental fluorescence spectra of the donor naphthalimide (NI, compound 6, Scheme 1) and acceptor fluorescein isothiocyanate (FITC) absorption is given in Figure 3.

The most important spectral characteristics of fluorophores were determined by the Forster model to calculate the characteristics of resonant transport: the absorption maximum wavelength, the maximum fluorescence wavelength, the extinction coefficient at the absorption maximum, the quantum yield fluorescence, lifetime of the excited state. [START_REF] Hanulia | Fluorescence life-time measurement excited with ultraviolet surface plasmon resonance[END_REF] The absorption and fluorescence spectra of individual naphthalimide and FITC are shown in Figures S1 andS2 in the Supporting Information. Spectral characteristics of individual chromophores NI (6), FITC, and protonated FITC form in a methanol-water mixture (v/v = 1:1) are presented in Table 1.

Results of the calculations based on the experimentally measured spectral characteristics of fluorophores are given in Table 2.

Also, we have studied resonance energy transfer process in the compound 10. Spectrscopic characteristics of 10 have been analyzed with respect to those of the individual dyes (NI and FITC) as well as with their equimolar mixture. The data obtained indicate the high efficiency of resonant transport in the FRET-pair 10, consistent with the theoretical calculation. For experimental details, see the Supporting Information (Figure S3).

Study of Acid-Catalyzed Cyclization of FRET-Model 10 Using Stationary and Time-Resolved Fluorescence Spectroscopy. To investigate the cyclization process of FRET-model 10, a series of solutions at acidic pH were prepared (5 × 10 -6 M of 10) in a water-methanol (1:1) mixture with HCl in 0 M, 1 × 10 -5 M, and 1 × 10 -4 M concentrations. The absorption spectra of these mixtures are presented in Figure 4.

The results of stationary fluorescence and fluorescence kinetics analysis are shown in Figure 5 and Figure S4. Fluorescence kinetics (Figure S4) analysis allowed for the calculation of the contribution of an exponent with a characteristic time of 6.0 ns corresponding to free naphthalimide-which was 52% (calculated from the known values [START_REF] Singharoy | Electron Transfer Switching Mechanism of a Naphthalimide Derivative with its Solvatochromic Behaviour An Experimental and Theoretical Study with In Cell Investigations[END_REF] of the pre-exponential factors = 619 /(619 + 561) = 0.52), i.e. there is an increase in contribution of this component if compared to neutral pH, where it was 37%. In the stationary spectra a significant decrease in the fluorescence intensity of the acceptor (λ = 518 nm) and the growth of donor fluorescence intensity (λ = 449 nm) are also observed, confirming the proposed hypothesis about compound 5 decomposition in a weakly acidic medium with the interruption of resonance energy transfer and a change in spectrum of fluorescence.

Thereby, in the studied FRET model of pH-sensitive thiourea an effective resonance energy transfer was observed, but decomposition of thiourea 10 took place in acidic medium (pH = 5) which was proved by a change in the fluorescence spectrum.

Thus, the hypothesis about the ability of sterically hindered derivatives of 2-thiohydantoin acid to cyclize in a weakly acidic medium was confirmed. Taking this into account it can be assumed the principle possibility of working out of pH-sensitive prodrugs of cytostatic molecules based on the same derivatives, capable of releasing the biologically active substance in the acidic medium of tumor tissue.

pH-Sensitive Thioureas Prodrugs Based on 3′-Amino-3′-deoxythymidine. To develop synthetic approaches to the acid-sensitive thiourea derivatives with sugar moieties we synthesized a model conjugate of the albutoin precursor with 3′-amino-3′-deoxythymidine.

Synthesis of 3′-Amino-3′-deoxythymidine Analogs of pH-Sensitive Thioureas. After multiple optimizations, we have proposed to introduce the drug fragment at the last stage of the synthesis, through the ester formation of the corresponding thiourea in the reaction with N-hydroxysuccinimide as an approach to twin 3′-amino-3′-deoxythymidine-based prodrug (Scheme 2).

Product 13 was isolated by preparative chromatography on silica gel and characterized by 1 H NMR spectroscopy and highresolution mass spectrometry. For a detailed description of the synthesis see the Supporting Information. Scheme 2. Synthesis of pH-Sensitive 3′-Amino-3′deoxythymidine-Albutoin Prodrug 13

Evaluation of pH-Sensitivity of Twin 3′-Amino-3′-deoxythymidine-Based Prodrug 13 by LC-MS. The thiourea-based prodrugs should release a biologically active substance and thiohydantoine in a weakly acidic medium. The model drug release from the conjugate of 3′-amino-3′-deoxythymidine with albutoin precursor 13 was studied in vitro under physiological conditions at different pH's.

Compound 13 was dissolved in formate buffer solutions with a pH of 5.5; 6.5; 7.4. The resulting mixtures were incubated at 37 °C for 24 h. Samples for analysis were taken at different time intervals, 0, 20, 40, 60, 90, 120, 240, 480, 1440 min, and analyzed by the LC-MS method. Relative rates of hydrolysis of the compound 13 over a 48-h period were calculated using the percent of prodrug 13 hydrolysis in acidic conditions; the relative rate of free aminothymidine accumulation was also measured. The conjugate 13 flow rate is shown in Figure 6, and the accumulation rate of the cyclization product 3′-amino-3′deoxythymidine is shown in Figure 7. We have suggested the following scheme for the release of 3′-amino-3′-deoxythymidine and albutoin, which proceeds in a slightly acidic solution pH ∼ 6.5 (Scheme 3).

We also have determined the kinetic parameters of this process. The reaction order for both the product and the reagent is zero. The ratio of the rate constants of the process at pH 7.4 (k1), pH 6.5 (k2), and pH 5.5 (k3) was k1:k2:k3 = 1:6.6:8.5. This data indicates the almost 10-fold increase in the rate of aminothymidine release at pH = 5.5 compared to neutral medium (pH = 7.4).

It should be noted that during the LC-MS analysis of compound 13 the signal of albutoin (m/z = 211.0911) was observed in all cases, which confirms that the cyclization reaction proceeds according with Scheme 3.

Thus, the resulting conjugate 13 is capable of releasing the starting drug and albutoin in a weakly acidic medium, but practically it does not disintegrate under neutral conditions. This suggests that such compounds in in vivo models would be selectively released in tumors (pH ∼ 6.5), [START_REF] Wei | pH-responsive pHLIP (pH low insertion peptide) nanoclusters of super-paramagnetic iron oxide nanoparticles as a tumor-selective MRI con-trast agent[END_REF] while in healthy tissues release of the drug should not occur.

Based on our result, we conclude that the cyclization of thioureas prodrug can occur under conditions corresponding to the tumor tissue. The next step is the synthesis of the anticancer drug (doxorubicin)-based thioureas.

pH-Sensitive Thiourea Prodrug Based on Doxorubicin. We have proposed a synthesis of twin doxorubicin-albutoin prodrug that can possess both antitumor and anticonvulsant properties. It was suggested that the introduction of an albutoin precursor fragment would reduce the toxicity in the neutral pH due to a significant change in the structure of the initial cytotoxic agent, but such a molecule will be able to release the initial drug in a weakly acidic pH of the tumor tissue medium, and also, higher lipophilicity of the thiourea-doxorubicin prodrug should improve cell penetration compared to unmodified doxorubicin, thereby lowering the effective drug dose reducing toxicity.

Synthesis of Doxorubicin Derivative of pH-Sensitive Thiourea. To obtain a twin doxorubicin-based prodrug 14 we have used a previously described three-step approach with intermediate preparation of the N-hydroxysuccinimide ester 12. The synthesis was carried out according to Scheme 4.

The product 14 was isolated by preparative chromatography on silica gel and characterized by [START_REF] Shu | Quercetin reverses the doxorubicin resistance of prostate cancer cells by downregulating the expression of c-met[END_REF] H NMR spectroscopy and high-resolution mass spectrometry. For a detailed description see the Supporting Information.

Evaluation of pH-Sensitivity of Twin Doxorubicin-Albutoin Prodrug 14 by LC-MS. Relative rates of compound 14 hydrolysis over a 48-h period were evaluated using the experimentally determined percentage of the initial doxorubicin-albutoin prodrug 14 under hydrolysis in acidic conditions at different pH's.

Prodrug 14 was incubated in aqueous formate buffer at pH 5.5, 6.5, and 7.4 at 37 °C over a 20-h period. The LC-MS technique was employed to analyze how much of compound 14 was hydrolyzed. We have demonstrated the ability of the derivative 14 to enter the acid-catalyzed cyclization reaction with the formation of albutoin and doxorubicin in a weakly acid solution. Sampling for LC-MS analysis was carried out at 0, 70, and 1210 min. The content of the initial conjugate was evaluated; the resulting concentration/time dependence in semilogarithmic coordinates is shown in Figure 8.

We have suggested the following scheme for the release of doxorubicin and albutoin, which proceeds in a slightly acidic solution pH ∼ 6.5 (Scheme 5).

The release of free doxorubicin reaches a value of 94% at pH = 5.5; 93% at pH = 6.5; and 89% at pH = 7.4. Analysis of the data in semilogarithmic coordinates allows for assumption of the first order of the reaction for the conjugate 14. On this base, the halftransformation times at different pH values were calculated, which are 300 min at pH = 5.5; 320 min at pH = 6.5; and 380 min at pH = 7.4.

Thus, the hypothesis of faster release of conjugate 14 in an acid medium was confirmed.

Previously, the fatty acid derivatives of doxorubicin have been synthesized. [START_REF] Chhikara | Fatty acyl amide derivatives of doxorubicin: Synthesis and in vitro anticancer activities[END_REF] These prodrugs are amides, and they possess generally lower toxicity compared to doxorubicin, which was explained by the high stability of amides to nonenzymatic hydrolysis under physiological conditions. Also, recently, adamantane-modified doxorubicin via amide and ester linkers was developed, and, also, these conjugates were found to be nontoxic and did not show the ability to release free Dox in weakly acidic medium. [START_REF] Gonzaĺez-Meńdez | Optimized synthesis, characterization and in vitro systematic evaluation of adamantane doxorubicin prodrugs sensitive to pH in breast cancer cells[END_REF] Thereby, previous attempts to obtain pH-sensitive prodrugs of doxorubicin, by modifying the 3′-NH 2 position with an amide bond, did not give satisfactory results on drug release and toxicity. The proposed concept of thiourea modification shows a proton-sensitive release even at pH 6.5. Due to the special structure of the introduced thiourea fragment, the resulting prodrug does not undergo hydrolysis according to the classical mechanism of amide hydrolysis, instead initiating the formation of a 2-thiohydantoin derivative with the release of the amide fragment. This reaction, unlike the hydrolysis of amides, easily occurs in weakly acidic media. The next step was to study the effect of thiourea modification on cytotoxicity.

In Vitro Studies of Compound 14 Cytotoxicity against PC3 Cell Line under Pre-Established Acidic Cancer Cell Culture Medium (pH < 7.0). After the studying the pH-sensitive dual prodrug 14 ability to release doxorubicin and albutoin in an acidic environment, we studied the effect of compound 14 on tumor cells of prostate cancer PC3. The cells treated with the same concentration of free doxorubicin were used as negative controls.

We have prepared two different cell cultures for comparison: one was incubated in standard nutrient medium with pH = 7.6, and the other one was adapted to conditions of tumor tissue with pH = 6.6. Previously it has been shown that a pH decrease of the nutrient medium from 7.4 to 6.7 does not affect the growth rate and the population of cells. [START_REF] Legigan | The First Generation of β-Galactosidase-Responsive Prodrugs Designed for the Selective Treatment of Solid Tumors in Prodrug Monotherapy[END_REF] This means that the cytotoxicity can be attributed exclusively to the effect of the test drug but not to the change in external conditions. Doxorubicin prodrug 14 and free doxorubicin were added to the aforementioned cultures. The MTT method [START_REF] Hassan | Cytotoxicity anticancer activities of anastrozole against breast, liver hepatocellular, and prostate cancer cells[END_REF] was used to study cell survival after incubation for 48 h.

We have detected a decrease in the toxicity of the conjugate 14 under study in a weakly alkaline medium corresponding to healthy tissues, compared with its toxicity in more acidic medium. IC50 values for doxorubicin prodrug 14 and doxorubicin in various media also were calculated and were found to be dramatically different (Table 3). The cytotoxicity curves of 14 and Dox at different concentrations are given in the Supporting Information (Figure S5).

Such different IC50 values for doxorubucin in different pH's can be explained by low cellular penetration, which occurs due to protonation. In addition to lipophilicity, the degree of molecular ionization, which is dependent on pH and pK a , determines the transport action. Doxorubicin acts as a weak base (pK a 8.34). [START_REF] Hematyar | Synergistic co-delivery of doxorubicin and melittin using functionalized magnetic nanoparticles for cancer treatment: loading and in vitro release study by LC-MS/MS[END_REF] Therefore, a decreasing extracellular pH leads to an increasing ionization of drug molecules, and, hence, drug transport into cells is rendered more difficult. [START_REF] Kleeberger | Effect of pH and moderate hyperthermia on doxorubicin, epirubicin and aclacinomycin A cytotoxicity for Chinese hamster ovary cells[END_REF] Thus, due to pK a value, doxorubicin shows increased toxicity to pH-neutral healthy tissues compared with pH-acidic tumor tissues; therefore, more hypophilic and penetrating prodrugs are promising analogues. Comparison of the cellular penetration of prodrug 14 with free doxorubicin is given in 2.3.4.

At pH = 7.6 high-lipophilic conjugate 14 penetrates into the cells, but Dox release does not take place sufficiently. However, a rather high toxicity even in a neutral medium compared to the low toxicity of prodrugs incapable of release [START_REF] Gonzaĺez-Meńdez | Optimized synthesis, characterization and in vitro systematic evaluation of adamantane doxorubicin prodrugs sensitive to pH in breast cancer cells[END_REF] suggests Dox releasing inside the cell in a weakly acidic environment of the endosomes (pH ∼ 6.0). This explains the similarity of the cytotoxicity values of 14 at different acidities of the medium -in Transport of anthracyclines is essentially influenced by the parameters pK a and polarity of the molecule. The intracellular drug concentration at steady state increases with increasing lipophilicity in the order doxorubicin, epirubicin, and aclacinomycin. [START_REF] Kleeberger | Effect of pH and moderate hyperthermia on doxorubicin, epirubicin and aclacinomycin A cytotoxicity for Chinese hamster ovary cells[END_REF] As we expected, 14 penetrates the cell much better than doxorubicin due to increased lipophilicity.

After penetrating the cell membrane and releasing from the endosome, most likely we observe a mixed signal of Dox, which has released from 14, and the conjugate 14 (Figure 9, C3). Also, high nucleous accumulation was observed (Figure 10, C3). It is well-known, that Dox is capable of nuclear accumulation, resulting in topoisomerase II inhibition. [START_REF] Nitiss | Targeting DNA topoisomerase II in cancer chemotherapy[END_REF] Prodrug 14, as well as higher cellular penetration, shows higher nuclear penetration in comparison with free doxorubicin (Figure 10, C3), which indicates that the prodrug 14, which did not undergo hydrolysis in the proteasome, penetrates into the cell nucleus as easily as into the cell, due to its lipophilicity. Also, cell nuclei accumulation was quantified, and average fluorescence signals for prodrug 14 and doxorubicin are presented in the Supporting Information (Figure S6, Table S1).

It should be noted that doxorubicin is not protonated in neutral pH 7.4 and possesses a strong cytotoxic effect (Table 3), but its penetration into the cell and nuclei is still extremely low (Figures 9,10,C2).

In the acidic pH of the tumor cells in vivo, doxorubicin will be protonated and shows even lower cellular accumulation. This would lead to a low effective dose of the drug and high toxicity.

Bioconjugation, an attachment of a bioactive molecule to another molecule via a covalent bond, leads to the formation of a novel chemical structure with may have enhanced properties compared to those of the original molecule. At the same time, as can be seen from the literature data, the bioconjugation of various molecules to doxorubicin often leads to a rapid decline in cytotoxic activity and biodistribution failure. Conjugating the dexamethasone molecule to Dox results in a more lipophilic conjugate, which also, like prodrug 14, more easily penetrates into the cell compared to the original doxorubicin. However, the conjugate with dexomethasone showed no ability to accumulate in the cell nuclei and also, as in the examples described above, shows toxicity to MCF-7 cells more than 20 times less compared to Dox. [START_REF] Chaikomon | Doxorubicinconjugated dexamethasone induced MCF-7 apoptosis without entering the nucleus and able to overcome MDR-1-induced resistance[END_REF] Prodrug 14, due to the pH-sensitive thiourea fragment, which increases the lipophilicity of the molecule, distribution rate, but which at the same time can be easily removed by cyclization, easily penetrates both into the cell and into cell nuclei.

Conjugate 14 is less toxic than doxorubicin in neutral pH (Table 3); however, it exhibits better cellular accumulation even at this pH value; at pH 6.5, 14 shows toxicity similar to doxorubicin (Table 3), due to a combination of high cellular penetration and pH-sensitive release doxorubicin and albutoin.

■ CONCLUSION

Summarizing the results, we have developed a methodology for the preparation of a naphthalimide-fluorescein FRET pair, which contains in the structure the fragment of thiohydantoin acid and is capable of an acid-catalyzed cyclization. The presence of resonant energy transfer in this system was predicted theoretically and confirmed experimentally, and the hypothesis about the FRET-pair cyclization in a weakly acidic medium was proved.

The method for the synthesis of a new pH-sensitive twin doxorubicin-thiourea prodrug was proposed. The ability of the resulting prodrug 14 to release cytotoxic and thiohydantoin components in a weakly acidic medium was confirmed. Using in vitro cytotoxicity studies, the selectivity of the pH-sensitive twin doxorubicin-albutoin prodrug toward PC3 prostate cancer cell line was compared to free doxorubicin. It was shown that the obtaining pH-sensitive twin doxorubicin-albutoin prodrug has more than a 30-fold selectivity increase toward healthy tissues compared to the free doxorubicin. Despite the fact that in neutral pH the toxicity of Dox and prodrug 14 is dramatically different, in acidic pH it is almost equal. Thiourea-modified doxorubicin 14 has shown better cellular and nuclei penetration in comparison with free Dox. Thus, the proposed approach to the modification of doxorubicin with pH-sensitive thioureas opens up possibilities for obtaining drugs of the same pharmacological efficacy on tumor tissues having a lower effective dose due to higher cellular penetration and the possibility of adding a second pharmacological action depending on the structure of the released thiohydantoin.

■ MATERIALS AND METHODS

Chemicals. Unless otherwise noted, all preparations were carried out in reagent grade solvents. All chemicals used in the synthesis were obtained from Acros or Sigma-Aldrich and were used without further purification. Solvents were deoxygenated/ distilled/purified by bubbling through a stream of argon or by conventional methods and dried over molecular sieves. Column chromatography was performed using silica gel 60-120 mesh, 100-200 mesh.

1 H NMR spectra were recorded on a Bruker-Avance instrument (operating at 400 MHz for 1H). As the solvent, deuterochloroform (CDCl 3 ) and dimethyl sulfoxide-d6 (DMSO-d 6 ) were used. Chemical shifts are given in parts per million on a scale δ with respect to hexamethyldisiloxane as an internal standard. High Resolution Mass Spectra (HRMS) were recorded on an Orbitrap Elite (Thermo Scientific) mass spectrometer with an IRET. To inject solutions with a concentration of 0.1 to 9 μg/ mL (in 1% formic acid in acetonitrile), direct injection into the ion source using a syringe pump (5 μL/min) was used. The spray voltage is ±3.5 kV, and the temperature of the capillary is 275 °C. Mass spectra were recorded using an Orbitrap analyzer with a resolution of 480,000 (1 microscan). The maximum input time is 900 ms, averaging over 9 spectra; the mass range is 90-2000 Da, and in some cases it is 200-4000 Da. For internal calibration, DMSO and diisooctyl phthalate signals (m/z 157.03515 and 413.26623) were used in the positive mode, and the dodecyl sulfate signal (m/z 265.14790) was used in the negative mode.

LCMS. For purification and analysis of samples we used the Shimadzu Prominence LC-20 system with a column oven and fraction collector coupled to a single quadrupole massspectrometer Shimadzu LCMS-2020 with a dual DUIS-ESI-APCI ionization source. The analytical and preparative column was Phenomenex Luna 3u C18 100A (150 × 4.6 mm). The mobile phases were as follows: A -0.1% formic acid in water, B -10 mM ammonium formate in water, D -acetonitrile.

LCMS parameters for analyses were as follows: gradient flow of 1 mL/min (0-0.5 min -5% D, 0.5-10.5 min -5% to 100% D, 10.5-12 min -100% D, 12-14.5 min -100% to 5% D), column oven temperature 40 °C, optional UV detection of some compounds.

MS parameters were as follows: drying gas 15.0 L/min, nebulizing gas 1.5 L/min, DL temperature 250 °C, heat block temperature 400 °C, interface voltage -3.5 kV, corona needle voltage -3.5 kV. Positive (mass range 250-2000 Da, in some cases 155-2000 Da) and negative ions (mass range 215-2000 Da) were registered. For hydrolysis kinetics study the SIM mode was used with registration of the molecular ions and adducts

[M + H] + , [M + Na] + , [M + K] + , [M -H] -, [M + HCOO] -.
HPLC. For purification of Fret-pair 10 we used identical LC parameters except gradient which was tailored for this compound (0-0.5 min -35% D, 0.5-5.5 min -35% to 55% D, 5.5-9.5 min -55% to 100% D, 9.5-10.5 min -100% D, 10.5-14 min -100% to 35% D). Fractionation was based on UV detection only (absorbance on 485 nm); fractions were collected based on UV signal level and slope.

Analytical Thin-Layer Chromatography. TLC was performed on Merck silica gel aluminum plates with F-254 indicator. Compounds were visualized by irradiation with UV light or iodine staining.

Geometry Estimation of Naphthalineimide-Fluorescein FRET-Model 10 Optimized by the PM6 Semiempirical Method. The three-dimensional structure of 10 was built with the MOPAC 2016 program package using the PM6 semiempirical method. [START_REF] Stewart | Optimization of parameters for semiempirical methods V: Modification of NDDO approximations and application to 70 elements[END_REF] The calculations were performed at optimized geometries, which reached gradient variations of less than 0.01 kcal/mol. The solvent effect was included in geometry optimizations following the Conductorlike Screening Model (COSMO) implemented in MOPAC. A dielectric constant of ε = 60 and a refraction index of solvent (n) such that n2 = 2 were used Experimental Study of Resonant Energy Transfer in the FRET Model. To confirm the presence of resonant energy transfer in the FRET model, the absorption and fluorescence spectra of the equimolar mixture naphthalimide + fluorescein isothiocyanate (NI 5 × 10 -6 M + FITC 5 × 10 -6 M) and the solution of FRET-model 5 * 10 -6 M were compared (excitation wavelength 370 nm) (Figure S3). Due to the instability of the FRET model, there was a partial decay during transportation to the place of investigation according to Figure S3. This resulted in the destruction of the FRET pair with the release of the compound containing the naphthalimide moiety. This process causes the appearance of an additional peak of fluorescence at λ = 449 nm. The time-resolved fluorescence spectra of the FRET model and naphthalimide were also recorded. The results are presented in the form of spectral-temporal maps and a plot of fluorescence intensity at different wavelengths versus time (Figure S3). It was found that the lifetime of the excited impurity state is 5.6 ns, and that of the test compound is 3.0 ns. The contribution of the exponential with the characteristic time 5.6 ns corresponding to the naphthalimide-containing impurity is 37% (calculated from the known values of the pre-exponential factors as 976/(976 + 1612) = 0.37). Taking into account the difference between the quantum yields of the fluorescence FRET model and naphthalimide, it was found that the impurity content is approximately 15%. Fluorescence of the acceptorfluorescein appears almost immediately after photoexcitation; fast relaxation of naphthalimide with a simultaneous rapid increase in the fluorescence intensity of the acceptor is not observed. The obtained data indicate the high efficiency of resonant transport in the system under investigation, consistent with the theoretical calculation. Spectral-temporal maps of the fluorescence FRET model and naphthalimide, fluorescence kinetics of the FRET model are shown in the Supporting Information (Figure S3).

Adaptation of PC3 Culture Cells to pH = 6.6. The PC3 line cells were incubated in the medium at t = 37 °C until spontaneous pH = 6.7. The cells were then transferred twice to RPMI-1640 medium with pH = 6.7 to adapt to a weakly acidic medium. After adaptation for 24 h, the pH of the medium was adjusted to 6.6 using KH 2 PO 4 . Cells were incubated in acidic medium for 48 h.

Cytotoxicity Study of 14. PC3 line cells incubated at pH 6.6 were suspended and transferred to 2 plates per 96 wells. Similarly, the culture of PC3 cells incubated at pH = 7.6 was reported. Subsequently, solutions of 14 and Doxorubicin in concentrations of 1 × 10 -4 g/L, 1 × 10 -3 g/L, 1 × 10 -2 g/L, 1 × 10 -1 g/L, and 1 g/L was added to both cell cultures. Cells were incubated for 48 h. Then, using the MTT method (using 3-(4,5dimethylthiazol-2-yl)-2,5-diphenyltetrazolium bromide as a colorant), the percentage of surviving cells was determined. As a control sample, cells not treated with cytotoxic drugs were used.

PC3 Cellular/Nucleus Accumulation Study. PC3 cells (10 5 cells/ml) were seated on Petri dishes with a glass bottom with a thickness of 0.17 mm. The experiment was carried out the next day (for the complete spreading of the cells and the acquisition of characteristic morphology by them). There were 3 samples: cells incubation with DOX (C ∼ 0.14 uM), cells incubation with 14 (C ∼ 1.192 uM), and incubation with a solvent (H 2 O) for 2 h. During incubation, cells were in phosphate-buffered saline (PBS) with the addition of 10 mM HEPES (to reduce autofluorescence due to components of the complete nutrient medium). Living cells were kept in a chamber with a maintained level of CO 2 , temperature, and humidity. DIC and DOX/14 fluorescence images (in the red fluorescent channel (561 nm) were obtained using a motorized inverted fluorescent microscope Eclipse Ti-E (Nikon) equipped with an iXon cooled EM-CCD camera (Andor), PerfectFocus (Nikon) autofocus system, and Plan Apo 40x lens (NA = 0.95). For DAPI vizualization, the cell preparations were fixed in 3.7% formaldehyde (Sigma-Aldrich, USA) prepared on PBS: washing from the retainer -3 times for 5 min. Next, 0.2 μg/mL DAPI (Cayman Chemical Company, USA) was added: washing -3 times for 5 min (PBS); further shooting in 2 channels -450 nm for DAPI and 561 for DOX and 14. Image processing was performed in the NIS-elements imaging software and in ImageJ.

■ ASSOCIATED CONTENT

* S Supporting Information

The Supporting Information is available free of charge on the ACS Publications website at DOI: 10.1021/acs.bioconjchem.8b00885.

Synthesis details, structural data, materials and methods (PDF)

■ AUTHOR INFORMATION

Corresponding Author *Phone: +7 495 9394020. Fax: +7 495 9328846. E-mail: krasnovskayao@gmail.com.

Scheme 1 .Figure 1 .

 11 Scheme 1. Synthesis of pH-Sensitive Thiourea 10 as a FRET-Model Molecule

Figure 2 .

 2 Figure 2. Geometry of a naphthalineimide-fluorescein FRET model optimized by the MM2 method.

Figure 3 .

 3 Figure 3. Superposition of the experimentally observed fluorescence spectra of the donor (NI, 1) and acceptor (FITC, 2).

Figure 4 .

 4 Figure 4. Absorption spectra of the FRET-pair 10 (5 × 10 -6 M) in a methanol-water mixture (v/v = 1:1) in the presence and absence of hydrochloric acid.

Figure 5 .

 5 Figure 5. Fluorescence spectra of the FRET-model 10 in a methanolwater mixture (v/v = 1:1) in the presence and absence of hydrochloric acid.

Figure 6 .

 6 Figure 6. Dependence of prodrug 13 concentration from the time of incubation in medium with different pH's.

Figure 7 .

 7 Figure 7. Dependence of 3′-amino-3′-deoxythymidine concentration from the time of incubation in medium with different pH's. Scheme 3. Proposed Way of Acid-Catalyzed Decomposition of the Model Conjugate 13 in a Weakly Acidic Medium

Figure 8 .

 8 Figure 8. Semilogarithmic dependence concentration of compound 14 on time incubation at various pH conditions.

Figure 9 .

 9 Figure 9. Cellular accumulation of 14 in PC3 cells: (A) PC3 cells treated with water (A1), doxorubicin (A2), and 14 (A3); (B) visualization of drugs in the red fluorescent channel (561 nm); and (C) merge of A and B.

Figure 10 .

 10 Figure 10. Cell nucleus accumulation of 14 in DAPI-labeled PC3 cells: (A) DAPI-labeled PC3 cells treated with water (A1), doxorubicin (A2), and 14 (A3), vizualization of DAPI in blue fluorescent channel (450 nm); (B) visualization of drugs in the red fluorescent channel (561 nm); and (C) merge of A and B.

Table 1 .

 1 Spectral Characteristics of Individual Chromophores Ni, FITC, and Protonated FITC Form in a Methanol-Water Mixture (v/v = 1:1)

	Compound	λ max abs /HM	ε • 10 -3 / M -1 •cM -1	λ max fl / HM	φ fl *	τ S / HC
	Naphthalimide NI	371	8.0	449	1.0	9.0
	(donor)
	FITC (acceptor)	492	31.4	518	0.23	3.6
	FITC + HCl (10 -4 )	453;480	7.8;7.2	514	0.11	2.4

Table 2

 2

	Compound	Overlap integral J(λ) L•nm 4 /mol•cm	Forster radius R0/Å	r/Å	k FRET /c -1	Φ FRET (FRET efficiency)
	FRET model	4.35 × 10 14	44.7	12.8	2.0 × 10 11	0.9994
	FRET model + H +	2.08 × 10 14	39.5	12.8	9.6 × 10 10	0.9988

. Theoretical Calculation of the Resonance Energy Transfer Process Characteristics According to the Forster Model in the NI-FIC Compound 10 and in the Protonated Form of NI-FITC

DOI: 10.1021/acs.bioconjchem.8b00885 Bioconjugate Chem. 2019, 30, 741-750

Author Contributions

The manuscript was written through contributions of all authors. All authors have given approval to the final version of the manuscript.

Notes

The authors declare no competing financial interest.

■ ACKNOWLEDGMENTS

The