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