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