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