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