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