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