Skip to content

Commit 18c329c

Browse files
sipasipa
committed
Remove the internal secp256k1_ecdsa_sig_t type
1 parent 74a2acd commit 18c329c

File tree

4 files changed

+94
-98
lines changed

4 files changed

+94
-98
lines changed

‎src/ecdsa.h

Lines changed: 5 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -11,14 +11,10 @@
1111
#include "group.h"
1212
#include "ecmult.h"
1313

14-
typedef struct {
15-
secp256k1_scalar_t r, s;
16-
} secp256k1_ecdsa_sig_t;
17-
18-
static int secp256k1_ecdsa_sig_parse(secp256k1_ecdsa_sig_t *r, const unsigned char *sig, int size);
19-
static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const secp256k1_ecdsa_sig_t *a);
20-
static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context_t *ctx, const secp256k1_ecdsa_sig_t *sig, const secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message);
21-
static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context_t *ctx, secp256k1_ecdsa_sig_t *sig, const secp256k1_scalar_t *seckey, const secp256k1_scalar_t *message, const secp256k1_scalar_t *nonce, int *recid);
22-
static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context_t *ctx, const secp256k1_ecdsa_sig_t *sig, secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message, int recid);
14+
static int secp256k1_ecdsa_sig_parse(secp256k1_scalar_t *r, secp256k1_scalar_t *s, const unsigned char *sig, int size);
15+
static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const secp256k1_scalar_t *r, const secp256k1_scalar_t *s);
16+
static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context_t *ctx, const secp256k1_scalar_t* r, const secp256k1_scalar_t* s, const secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message);
17+
static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context_t *ctx, secp256k1_scalar_t* r, secp256k1_scalar_t* s, const secp256k1_scalar_t *seckey, const secp256k1_scalar_t *message, const secp256k1_scalar_t *nonce, int *recid);
18+
static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context_t *ctx, const secp256k1_scalar_t* r, const secp256k1_scalar_t* s, secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message, int recid);
2319

2420
#endif

‎src/ecdsa_impl.h

Lines changed: 25 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ static const secp256k1_fe_t secp256k1_ecdsa_const_p_minus_order = SECP256K1_FE_C
4646
0, 0, 0, 1, 0x45512319UL, 0x50B75FC4UL, 0x402DA172UL, 0x2FC9BAEEUL
4747
);
4848

49-
static int secp256k1_ecdsa_sig_parse(secp256k1_ecdsa_sig_t *r, const unsigned char *sig, int size) {
49+
static int secp256k1_ecdsa_sig_parse(secp256k1_scalar_t *rr, secp256k1_scalar_t *rs, const unsigned char *sig, int size) {
5050
unsigned char ra[32] = {0}, sa[32] = {0};
5151
const unsigned char *rp;
5252
const unsigned char *sp;
@@ -98,23 +98,23 @@ static int secp256k1_ecdsa_sig_parse(secp256k1_ecdsa_sig_t *r, const unsigned ch
9898
memcpy(ra + 32 - lenr, rp, lenr);
9999
memcpy(sa + 32 - lens, sp, lens);
100100
overflow = 0;
101-
secp256k1_scalar_set_b32(&r->r, ra, &overflow);
101+
secp256k1_scalar_set_b32(rr, ra, &overflow);
102102
if (overflow) {
103103
return 0;
104104
}
105-
secp256k1_scalar_set_b32(&r->s, sa, &overflow);
105+
secp256k1_scalar_set_b32(rs, sa, &overflow);
106106
if (overflow) {
107107
return 0;
108108
}
109109
return 1;
110110
}
111111

112-
static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const secp256k1_ecdsa_sig_t *a) {
112+
static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const secp256k1_scalar_t* ar, const secp256k1_scalar_t* as) {
113113
unsigned char r[33] = {0}, s[33] = {0};
114114
unsigned char *rp = r, *sp = s;
115115
int lenR = 33, lenS = 33;
116-
secp256k1_scalar_get_b32(&r[1], &a->r);
117-
secp256k1_scalar_get_b32(&s[1], &a->s);
116+
secp256k1_scalar_get_b32(&r[1], ar);
117+
secp256k1_scalar_get_b32(&s[1], as);
118118
while (lenR > 1 && rp[0] == 0 && rp[1] < 0x80) { lenR--; rp++; }
119119
while (lenS > 1 && sp[0] == 0 && sp[1] < 0x80) { lenS--; sp++; }
120120
if (*size < 6+lenS+lenR) {
@@ -133,26 +133,26 @@ static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, int *size, const se
133133
return 1;
134134
}
135135

136-
static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context_t *ctx, const secp256k1_ecdsa_sig_t *sig, const secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message) {
136+
static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context_t *ctx, const secp256k1_scalar_t *sigr, const secp256k1_scalar_t *sigs, const secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message) {
137137
unsigned char c[32];
138138
secp256k1_scalar_t sn, u1, u2;
139139
secp256k1_fe_t xr;
140140
secp256k1_gej_t pubkeyj;
141141
secp256k1_gej_t pr;
142142

143-
if (secp256k1_scalar_is_zero(&sig->r) || secp256k1_scalar_is_zero(&sig->s)) {
143+
if (secp256k1_scalar_is_zero(sigr) || secp256k1_scalar_is_zero(sigs)) {
144144
return 0;
145145
}
146146

147-
secp256k1_scalar_inverse_var(&sn, &sig->s);
147+
secp256k1_scalar_inverse_var(&sn, sigs);
148148
secp256k1_scalar_mul(&u1, &sn, message);
149-
secp256k1_scalar_mul(&u2, &sn, &sig->r);
149+
secp256k1_scalar_mul(&u2, &sn, sigr);
150150
secp256k1_gej_set_ge(&pubkeyj, pubkey);
151151
secp256k1_ecmult(ctx, &pr, &pubkeyj, &u2, &u1);
152152
if (secp256k1_gej_is_infinity(&pr)) {
153153
return 0;
154154
}
155-
secp256k1_scalar_get_b32(c, &sig->r);
155+
secp256k1_scalar_get_b32(c, sigr);
156156
secp256k1_fe_set_b32(&xr, c);
157157

158158
/** We now have the recomputed R point in pr, and its claimed x coordinate (modulo n)
@@ -187,19 +187,19 @@ static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context_t *ctx, con
187187
return 0;
188188
}
189189

190-
static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context_t *ctx, const secp256k1_ecdsa_sig_t *sig, secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message, int recid) {
190+
static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context_t *ctx, const secp256k1_scalar_t *sigr, const secp256k1_scalar_t* sigs, secp256k1_ge_t *pubkey, const secp256k1_scalar_t *message, int recid) {
191191
unsigned char brx[32];
192192
secp256k1_fe_t fx;
193193
secp256k1_ge_t x;
194194
secp256k1_gej_t xj;
195195
secp256k1_scalar_t rn, u1, u2;
196196
secp256k1_gej_t qj;
197197

198-
if (secp256k1_scalar_is_zero(&sig->r) || secp256k1_scalar_is_zero(&sig->s)) {
198+
if (secp256k1_scalar_is_zero(sigr) || secp256k1_scalar_is_zero(sigs)) {
199199
return 0;
200200
}
201201

202-
secp256k1_scalar_get_b32(brx, &sig->r);
202+
secp256k1_scalar_get_b32(brx, sigr);
203203
VERIFY_CHECK(secp256k1_fe_set_b32(&fx, brx)); /* brx comes from a scalar, so is less than the order; certainly less than p */
204204
if (recid & 2) {
205205
if (secp256k1_fe_cmp_var(&fx, &secp256k1_ecdsa_const_p_minus_order) >= 0) {
@@ -211,16 +211,16 @@ static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context_t *ctx, co
211211
return 0;
212212
}
213213
secp256k1_gej_set_ge(&xj, &x);
214-
secp256k1_scalar_inverse_var(&rn, &sig->r);
214+
secp256k1_scalar_inverse_var(&rn, sigr);
215215
secp256k1_scalar_mul(&u1, &rn, message);
216216
secp256k1_scalar_negate(&u1, &u1);
217-
secp256k1_scalar_mul(&u2, &rn, &sig->s);
217+
secp256k1_scalar_mul(&u2, &rn, sigs);
218218
secp256k1_ecmult(ctx, &qj, &xj, &u2, &u1);
219219
secp256k1_ge_set_gej_var(pubkey, &qj);
220220
return !secp256k1_gej_is_infinity(&qj);
221221
}
222222

223-
static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context_t *ctx, secp256k1_ecdsa_sig_t *sig, const secp256k1_scalar_t *seckey, const secp256k1_scalar_t *message, const secp256k1_scalar_t *nonce, int *recid) {
223+
static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context_t *ctx, secp256k1_scalar_t *sigr, secp256k1_scalar_t *sigs, const secp256k1_scalar_t *seckey, const secp256k1_scalar_t *message, const secp256k1_scalar_t *nonce, int *recid) {
224224
unsigned char b[32];
225225
secp256k1_gej_t rp;
226226
secp256k1_ge_t r;
@@ -232,8 +232,8 @@ static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context_t *ctx, s
232232
secp256k1_fe_normalize(&r.x);
233233
secp256k1_fe_normalize(&r.y);
234234
secp256k1_fe_get_b32(b, &r.x);
235-
secp256k1_scalar_set_b32(&sig->r, b, &overflow);
236-
if (secp256k1_scalar_is_zero(&sig->r)) {
235+
secp256k1_scalar_set_b32(sigr, b, &overflow);
236+
if (secp256k1_scalar_is_zero(sigr)) {
237237
/* P.x = order is on the curve, so technically sig->r could end up zero, which would be an invalid signature. */
238238
secp256k1_gej_clear(&rp);
239239
secp256k1_ge_clear(&r);
@@ -242,18 +242,18 @@ static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context_t *ctx, s
242242
if (recid) {
243243
*recid = (overflow ? 2 : 0) | (secp256k1_fe_is_odd(&r.y) ? 1 : 0);
244244
}
245-
secp256k1_scalar_mul(&n, &sig->r, seckey);
245+
secp256k1_scalar_mul(&n, sigr, seckey);
246246
secp256k1_scalar_add(&n, &n, message);
247-
secp256k1_scalar_inverse(&sig->s, nonce);
248-
secp256k1_scalar_mul(&sig->s, &sig->s, &n);
247+
secp256k1_scalar_inverse(sigs, nonce);
248+
secp256k1_scalar_mul(sigs, sigs, &n);
249249
secp256k1_scalar_clear(&n);
250250
secp256k1_gej_clear(&rp);
251251
secp256k1_ge_clear(&r);
252-
if (secp256k1_scalar_is_zero(&sig->s)) {
252+
if (secp256k1_scalar_is_zero(sigs)) {
253253
return 0;
254254
}
255-
if (secp256k1_scalar_is_high(&sig->s)) {
256-
secp256k1_scalar_negate(&sig->s, &sig->s);
255+
if (secp256k1_scalar_is_high(sigs)) {
256+
secp256k1_scalar_negate(sigs, sigs);
257257
if (recid) {
258258
*recid ^= 1;
259259
}

‎src/secp256k1.c

Lines changed: 33 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -108,42 +108,42 @@ int secp256k1_ec_pubkey_serialize(const secp256k1_context_t* ctx, unsigned char
108108
return secp256k1_eckey_pubkey_serialize(&Q, output, outputlen, compressed);
109109
}
110110

111-
static void secp256k1_ecdsa_signature_load(secp256k1_ecdsa_sig_t* s, int* recid, const secp256k1_ecdsa_signature_t* sig) {
111+
static void secp256k1_ecdsa_signature_load(secp256k1_scalar_t* r, secp256k1_scalar_t* s, int* recid, const secp256k1_ecdsa_signature_t* sig) {
112112
if (sizeof(secp256k1_scalar_t) == 32) {
113113
/* When the secp256k1_scalar_t type is exactly 32 byte, use its
114114
* representation inside secp256k1_ecdsa_signature_t, as conversion is very fast.
115115
* Note that secp256k1_ecdsa_signature_save must use the same representation. */
116-
memcpy(&s->r, &sig->data[0], 32);
117-
memcpy(&s->s, &sig->data[32], 32);
116+
memcpy(r, &sig->data[0], 32);
117+
memcpy(s, &sig->data[32], 32);
118118
} else {
119-
secp256k1_scalar_set_b32(&s->r, &sig->data[0], NULL);
120-
secp256k1_scalar_set_b32(&s->s, &sig->data[32], NULL);
119+
secp256k1_scalar_set_b32(r, &sig->data[0], NULL);
120+
secp256k1_scalar_set_b32(s, &sig->data[32], NULL);
121121
}
122122
if (recid) {
123123
*recid = sig->data[64];
124124
}
125125
}
126126

127-
static void secp256k1_ecdsa_signature_save(secp256k1_ecdsa_signature_t* sig, const secp256k1_ecdsa_sig_t* s, int recid) {
127+
static void secp256k1_ecdsa_signature_save(secp256k1_ecdsa_signature_t* sig, const secp256k1_scalar_t* r, const secp256k1_scalar_t* s, int recid) {
128128
if (sizeof(secp256k1_scalar_t) == 32) {
129-
memcpy(&sig->data[0], &s->r, 32);
130-
memcpy(&sig->data[32], &s->s, 32);
129+
memcpy(&sig->data[0], r, 32);
130+
memcpy(&sig->data[32], s, 32);
131131
} else {
132-
secp256k1_scalar_get_b32(&sig->data[0], &s->r);
133-
secp256k1_scalar_get_b32(&sig->data[32], &s->s);
132+
secp256k1_scalar_get_b32(&sig->data[0], r);
133+
secp256k1_scalar_get_b32(&sig->data[32], s);
134134
}
135135
sig->data[64] = recid;
136136
}
137137

138138
int secp256k1_ecdsa_signature_parse_der(const secp256k1_context_t* ctx, secp256k1_ecdsa_signature_t* sig, const unsigned char *input, int inputlen) {
139-
secp256k1_ecdsa_sig_t s;
139+
secp256k1_scalar_t r, s;
140140

141141
(void)ctx;
142142
DEBUG_CHECK(sig != NULL);
143143
DEBUG_CHECK(input != NULL);
144144

145-
if (secp256k1_ecdsa_sig_parse(&s, input, inputlen)) {
146-
secp256k1_ecdsa_signature_save(sig, &s, -1);
145+
if (secp256k1_ecdsa_sig_parse(&r, &s, input, inputlen)) {
146+
secp256k1_ecdsa_signature_save(sig, &r, &s, -1);
147147
return 1;
148148
} else {
149149
memset(sig, 0, sizeof(*sig));
@@ -152,50 +152,50 @@ int secp256k1_ecdsa_signature_parse_der(const secp256k1_context_t* ctx, secp256k
152152
}
153153

154154
int secp256k1_ecdsa_signature_parse_compact(const secp256k1_context_t* ctx, secp256k1_ecdsa_signature_t* sig, const unsigned char *input64, int recid) {
155-
secp256k1_ecdsa_sig_t s;
155+
secp256k1_scalar_t r, s;
156156
int ret = 1;
157157
int overflow = 0;
158158

159159
(void)ctx;
160160
DEBUG_CHECK(sig != NULL);
161161
DEBUG_CHECK(input64 != NULL);
162162

163-
secp256k1_scalar_set_b32(&s.r, &input64[0], &overflow);
163+
secp256k1_scalar_set_b32(&r, &input64[0], &overflow);
164164
ret &= !overflow;
165-
secp256k1_scalar_set_b32(&s.s, &input64[32], &overflow);
165+
secp256k1_scalar_set_b32(&s, &input64[32], &overflow);
166166
ret &= !overflow;
167167
ret &= (recid == -1 || (recid >= 0 && recid < 4));
168168
if (ret) {
169-
secp256k1_ecdsa_signature_save(sig, &s, recid);
169+
secp256k1_ecdsa_signature_save(sig, &r, &s, recid);
170170
} else {
171171
memset(sig, 0, sizeof(*sig));
172172
}
173173
return ret;
174174
}
175175

176176
int secp256k1_ecdsa_signature_serialize_der(const secp256k1_context_t* ctx, unsigned char *output, int *outputlen, const secp256k1_ecdsa_signature_t* sig) {
177-
secp256k1_ecdsa_sig_t s;
177+
secp256k1_scalar_t r, s;
178178

179179
(void)ctx;
180180
DEBUG_CHECK(output != NULL);
181181
DEBUG_CHECK(outputlen != NULL);
182182
DEBUG_CHECK(sig != NULL);
183183

184-
secp256k1_ecdsa_signature_load(&s, NULL, sig);
185-
return secp256k1_ecdsa_sig_serialize(output, outputlen, &s);
184+
secp256k1_ecdsa_signature_load(&r, &s, NULL, sig);
185+
return secp256k1_ecdsa_sig_serialize(output, outputlen, &r, &s);
186186
}
187187

188188
int secp256k1_ecdsa_signature_serialize_compact(const secp256k1_context_t* ctx, unsigned char *output64, int *recid, const secp256k1_ecdsa_signature_t* sig) {
189-
secp256k1_ecdsa_sig_t s;
189+
secp256k1_scalar_t r, s;
190190
int rec;
191191

192192
(void)ctx;
193193
DEBUG_CHECK(output64 != NULL);
194194
DEBUG_CHECK(sig != NULL);
195195

196-
secp256k1_ecdsa_signature_load(&s, &rec, sig);
197-
secp256k1_scalar_get_b32(&output64[0], &s.r);
198-
secp256k1_scalar_get_b32(&output64[32], &s.s);
196+
secp256k1_ecdsa_signature_load(&r, &s, &rec, sig);
197+
secp256k1_scalar_get_b32(&output64[0], &r);
198+
secp256k1_scalar_get_b32(&output64[32], &s);
199199
if (recid) {
200200
DEBUG_CHECK(rec >= 0 && rec < 4);
201201
*recid = rec;
@@ -205,7 +205,7 @@ int secp256k1_ecdsa_signature_serialize_compact(const secp256k1_context_t* ctx,
205205

206206
int secp256k1_ecdsa_verify(const secp256k1_context_t* ctx, const unsigned char *msg32, const secp256k1_ecdsa_signature_t *sig, const secp256k1_pubkey_t *pubkey) {
207207
secp256k1_ge_t q;
208-
secp256k1_ecdsa_sig_t s;
208+
secp256k1_scalar_t r, s;
209209
secp256k1_scalar_t m;
210210
DEBUG_CHECK(ctx != NULL);
211211
DEBUG_CHECK(secp256k1_ecmult_context_is_built(&ctx->ecmult_ctx));
@@ -215,8 +215,8 @@ int secp256k1_ecdsa_verify(const secp256k1_context_t* ctx, const unsigned char *
215215

216216
secp256k1_scalar_set_b32(&m, msg32, NULL);
217217
secp256k1_pubkey_load(&q, pubkey);
218-
secp256k1_ecdsa_signature_load(&s, NULL, sig);
219-
return secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &s, &q, &m);
218+
secp256k1_ecdsa_signature_load(&r, &s, NULL, sig);
219+
return secp256k1_ecdsa_sig_verify(&ctx->ecmult_ctx, &r, &s, &q, &m);
220220
}
221221

222222
static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned char *msg32, const unsigned char *key32, unsigned int counter, const void *data) {
@@ -245,7 +245,7 @@ const secp256k1_nonce_function_t secp256k1_nonce_function_rfc6979 = nonce_functi
245245
const secp256k1_nonce_function_t secp256k1_nonce_function_default = nonce_function_rfc6979;
246246

247247
int secp256k1_ecdsa_sign(const secp256k1_context_t* ctx, const unsigned char *msg32, secp256k1_ecdsa_signature_t *signature, const unsigned char *seckey, secp256k1_nonce_function_t noncefp, const void* noncedata) {
248-
secp256k1_ecdsa_sig_t sig;
248+
secp256k1_scalar_t r, s;
249249
secp256k1_scalar_t sec, non, msg;
250250
int recid;
251251
int ret = 0;
@@ -273,7 +273,7 @@ int secp256k1_ecdsa_sign(const secp256k1_context_t* ctx, const unsigned char *ms
273273
secp256k1_scalar_set_b32(&non, nonce32, &overflow);
274274
memset(nonce32, 0, 32);
275275
if (!secp256k1_scalar_is_zero(&non) && !overflow) {
276-
if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &sig, &sec, &msg, &non, &recid)) {
276+
if (secp256k1_ecdsa_sig_sign(&ctx->ecmult_gen_ctx, &r, &s, &sec, &msg, &non, &recid)) {
277277
break;
278278
}
279279
}
@@ -284,7 +284,7 @@ int secp256k1_ecdsa_sign(const secp256k1_context_t* ctx, const unsigned char *ms
284284
secp256k1_scalar_clear(&sec);
285285
}
286286
if (ret) {
287-
secp256k1_ecdsa_signature_save(signature, &sig, recid);
287+
secp256k1_ecdsa_signature_save(signature, &r, &s, recid);
288288
} else {
289289
memset(signature, 0, sizeof(*signature));
290290
}
@@ -293,7 +293,7 @@ int secp256k1_ecdsa_sign(const secp256k1_context_t* ctx, const unsigned char *ms
293293

294294
int secp256k1_ecdsa_recover(const secp256k1_context_t* ctx, const unsigned char *msg32, const secp256k1_ecdsa_signature_t *signature, secp256k1_pubkey_t *pubkey) {
295295
secp256k1_ge_t q;
296-
secp256k1_ecdsa_sig_t sig;
296+
secp256k1_scalar_t r, s;
297297
secp256k1_scalar_t m;
298298
int recid;
299299
DEBUG_CHECK(ctx != NULL);
@@ -302,10 +302,10 @@ int secp256k1_ecdsa_recover(const secp256k1_context_t* ctx, const unsigned char
302302
DEBUG_CHECK(signature != NULL);
303303
DEBUG_CHECK(pubkey != NULL);
304304

305-
secp256k1_ecdsa_signature_load(&sig, &recid, signature);
305+
secp256k1_ecdsa_signature_load(&r, &s, &recid, signature);
306306
DEBUG_CHECK(recid >= 0 && recid < 4);
307307
secp256k1_scalar_set_b32(&m, msg32, NULL);
308-
if (secp256k1_ecdsa_sig_recover(&ctx->ecmult_ctx, &sig, &q, &m, recid)) {
308+
if (secp256k1_ecdsa_sig_recover(&ctx->ecmult_ctx, &r, &s, &q, &m, recid)) {
309309
secp256k1_pubkey_save(pubkey, &q);
310310
return 1;
311311
} else {

0 commit comments

Comments
 (0)