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