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