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