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