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