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