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