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