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