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