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