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