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