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