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