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