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