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