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