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