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