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