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