diff --git a/src/secp256k1.c b/src/secp256k1.c
index ade28319f..36fde24c3 100644
--- a/src/secp256k1.c
+++ b/src/secp256k1.c
@@ -60,7 +60,7 @@ static const secp256k1_context secp256k1_context_no_precomp_ = {
 const secp256k1_context *secp256k1_context_no_precomp = &secp256k1_context_no_precomp_;
 
 size_t secp256k1_context_preallocated_size(unsigned int flags) {
-    size_t ret = ROUND_TO_ALIGN(sizeof(secp256k1_context));
+    size_t ret = sizeof(secp256k1_context);
     /* A return value of 0 is reserved as an indicator for errors when we call this function internally. */
     VERIFY_CHECK(ret != 0);
 
@@ -74,13 +74,12 @@ size_t secp256k1_context_preallocated_size(unsigned int flags) {
 }
 
 size_t secp256k1_context_preallocated_clone_size(const secp256k1_context* ctx) {
-    size_t ret = ROUND_TO_ALIGN(sizeof(secp256k1_context));
+    size_t ret = sizeof(secp256k1_context);
     VERIFY_CHECK(ctx != NULL);
     return ret;
 }
 
 secp256k1_context* secp256k1_context_preallocated_create(void* prealloc, unsigned int flags) {
-    void* const base = prealloc;
     size_t prealloc_size;
     secp256k1_context* ret;
 
@@ -93,7 +92,7 @@ secp256k1_context* secp256k1_context_preallocated_create(void* prealloc, unsigne
         return NULL;
     }
     VERIFY_CHECK(prealloc != NULL);
-    ret = (secp256k1_context*)manual_alloc(&prealloc, sizeof(secp256k1_context), base, prealloc_size);
+    ret = (secp256k1_context*)prealloc;
     ret->illegal_callback = default_illegal_callback;
     ret->error_callback = default_error_callback;
 
@@ -102,7 +101,7 @@ secp256k1_context* secp256k1_context_preallocated_create(void* prealloc, unsigne
     secp256k1_ecmult_gen_context_build(&ret->ecmult_gen_ctx);
     ret->declassify = !!(flags & SECP256K1_FLAGS_BIT_CONTEXT_DECLASSIFY);
 
-    return (secp256k1_context*) ret;
+    return ret;
 }
 
 secp256k1_context* secp256k1_context_create(unsigned int flags) {
@@ -117,14 +116,12 @@ secp256k1_context* secp256k1_context_create(unsigned int flags) {
 }
 
 secp256k1_context* secp256k1_context_preallocated_clone(const secp256k1_context* ctx, void* prealloc) {
-    size_t prealloc_size;
     secp256k1_context* ret;
     VERIFY_CHECK(ctx != NULL);
     ARG_CHECK(prealloc != NULL);
 
-    prealloc_size = secp256k1_context_preallocated_clone_size(ctx);
     ret = (secp256k1_context*)prealloc;
-    memcpy(ret, ctx, prealloc_size);
+    *ret = *ctx;
     return ret;
 }
 
diff --git a/src/util.h b/src/util.h
index 818d40e66..04227a7c9 100644
--- a/src/util.h
+++ b/src/util.h
@@ -142,38 +142,6 @@ static SECP256K1_INLINE void *checked_realloc(const secp256k1_callback* cb, void
 
 #define ROUND_TO_ALIGN(size) ((((size) + ALIGNMENT - 1) / ALIGNMENT) * ALIGNMENT)
 
-/* Assume there is a contiguous memory object with bounds [base, base + max_size)
- * of which the memory range [base, *prealloc_ptr) is already allocated for usage,
- * where *prealloc_ptr is an aligned pointer. In that setting, this functions
- * reserves the subobject [*prealloc_ptr, *prealloc_ptr + alloc_size) of
- * alloc_size bytes by increasing *prealloc_ptr accordingly, taking into account
- * alignment requirements.
- *
- * The function returns an aligned pointer to the newly allocated subobject.
- *
- * This is useful for manual memory management: if we're simply given a block
- * [base, base + max_size), the caller can use this function to allocate memory
- * in this block and keep track of the current allocation state with *prealloc_ptr.
- *
- * It is VERIFY_CHECKed that there is enough space left in the memory object and
- * *prealloc_ptr is aligned relative to base.
- */
-static SECP256K1_INLINE void *manual_alloc(void** prealloc_ptr, size_t alloc_size, void* base, size_t max_size) {
-    size_t aligned_alloc_size = ROUND_TO_ALIGN(alloc_size);
-    void* ret;
-    VERIFY_CHECK(prealloc_ptr != NULL);
-    VERIFY_CHECK(*prealloc_ptr != NULL);
-    VERIFY_CHECK(base != NULL);
-    VERIFY_CHECK((unsigned char*)*prealloc_ptr >= (unsigned char*)base);
-    VERIFY_CHECK(((unsigned char*)*prealloc_ptr - (unsigned char*)base) % ALIGNMENT == 0);
-    VERIFY_CHECK((unsigned char*)*prealloc_ptr - (unsigned char*)base + aligned_alloc_size <= max_size);
-    /* Avoid unused parameter warnings when building without VERIFY */
-    (void) base; (void) max_size;
-    ret = *prealloc_ptr;
-    *prealloc_ptr = (unsigned char*)*prealloc_ptr + aligned_alloc_size;
-    return ret;
-}
-
 /* Macro for restrict, when available and not in a VERIFY build. */
 #if defined(SECP256K1_BUILD) && defined(VERIFY)
 # define SECP256K1_RESTRICT