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