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