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